//===----------------------------------------------------------------------===//
//
// This source file is part of the Soto for AWS open source project
//
// Copyright (c) 2017-2024 the Soto project authors
// Licensed under Apache License v2.0
//
// See LICENSE.txt for license information
// See CONTRIBUTORS.txt for the list of Soto project authors
//
// SPDX-License-Identifier: Apache-2.0
//
//===----------------------------------------------------------------------===//

// THIS FILE IS AUTOMATICALLY GENERATED by https://github.com/soto-project/soto-codegenerator.
// DO NOT EDIT.

#if canImport(FoundationEssentials)
import FoundationEssentials
#else
import Foundation
#endif
@_exported import SotoCore

/// Service object for interacting with AWS Macie2 service.
///
/// Amazon Macie
public struct Macie2: AWSService {
    // MARK: Member variables

    /// Client used for communication with AWS
    public let client: AWSClient
    /// Service configuration
    public let config: AWSServiceConfig

    // MARK: Initialization

    /// Initialize the Macie2 client
    /// - parameters:
    ///     - client: AWSClient used to process requests
    ///     - region: Region of server you want to communicate with. This will override the partition parameter.
    ///     - partition: AWS partition where service resides, standard (.aws), china (.awscn), government (.awsusgov).
    ///     - endpoint: Custom endpoint URL to use instead of standard AWS servers
    ///     - middleware: Middleware chain used to edit requests before they are sent and responses before they are decoded 
    ///     - timeout: Timeout value for HTTP requests
    ///     - byteBufferAllocator: Allocator for ByteBuffers
    ///     - options: Service options
    public init(
        client: AWSClient,
        region: SotoCore.Region? = nil,
        partition: AWSPartition = .aws,
        endpoint: String? = nil,
        middleware: AWSMiddlewareProtocol? = nil,
        timeout: TimeAmount? = nil,
        byteBufferAllocator: ByteBufferAllocator = ByteBufferAllocator(),
        options: AWSServiceConfig.Options = []
    ) {
        self.client = client
        self.config = AWSServiceConfig(
            region: region,
            partition: region?.partition ?? partition,
            serviceName: "Macie2",
            serviceIdentifier: "macie2",
            serviceProtocol: .restjson,
            apiVersion: "2020-01-01",
            endpoint: endpoint,
            variantEndpoints: Self.variantEndpoints,
            errorType: Macie2ErrorType.self,
            middleware: middleware,
            timeout: timeout,
            byteBufferAllocator: byteBufferAllocator,
            options: options
        )
    }




    /// FIPS and dualstack endpoints
    static var variantEndpoints: [EndpointVariantType: AWSServiceConfig.EndpointVariant] {[
        [.dualstack]: .init(endpoints: [
            "af-south-1": "macie2.af-south-1.api.aws",
            "ap-east-1": "macie2.ap-east-1.api.aws",
            "ap-northeast-1": "macie2.ap-northeast-1.api.aws",
            "ap-northeast-2": "macie2.ap-northeast-2.api.aws",
            "ap-northeast-3": "macie2.ap-northeast-3.api.aws",
            "ap-south-1": "macie2.ap-south-1.api.aws",
            "ap-southeast-1": "macie2.ap-southeast-1.api.aws",
            "ap-southeast-2": "macie2.ap-southeast-2.api.aws",
            "ca-central-1": "macie2.ca-central-1.api.aws",
            "eu-central-1": "macie2.eu-central-1.api.aws",
            "eu-north-1": "macie2.eu-north-1.api.aws",
            "eu-south-1": "macie2.eu-south-1.api.aws",
            "eu-west-1": "macie2.eu-west-1.api.aws",
            "eu-west-2": "macie2.eu-west-2.api.aws",
            "eu-west-3": "macie2.eu-west-3.api.aws",
            "il-central-1": "macie2.il-central-1.api.aws",
            "me-south-1": "macie2.me-south-1.api.aws",
            "sa-east-1": "macie2.sa-east-1.api.aws",
            "us-east-1": "macie2.us-east-1.api.aws",
            "us-east-2": "macie2.us-east-2.api.aws",
            "us-west-1": "macie2.us-west-1.api.aws",
            "us-west-2": "macie2.us-west-2.api.aws"
        ]),
        [.dualstack, .fips]: .init(endpoints: [
            "us-east-1": "macie2-fips.us-east-1.api.aws",
            "us-east-2": "macie2-fips.us-east-2.api.aws",
            "us-west-1": "macie2-fips.us-west-1.api.aws",
            "us-west-2": "macie2-fips.us-west-2.api.aws"
        ]),
        [.fips]: .init(endpoints: [
            "us-east-1": "macie2-fips.us-east-1.amazonaws.com",
            "us-east-2": "macie2-fips.us-east-2.amazonaws.com",
            "us-west-1": "macie2-fips.us-west-1.amazonaws.com",
            "us-west-2": "macie2-fips.us-west-2.amazonaws.com"
        ])
    ]}

    // MARK: API Calls

    /// Accepts an Amazon Macie membership invitation that was received from a specific account.
    @Sendable
    @inlinable
    public func acceptInvitation(_ input: AcceptInvitationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> AcceptInvitationResponse {
        try await self.client.execute(
            operation: "AcceptInvitation", 
            path: "/invitations/accept", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Accepts an Amazon Macie membership invitation that was received from a specific account.
    ///
    /// Parameters:
    ///   - administratorAccountId: The Amazon Web Services account ID for the account that sent the invitation.
    ///   - invitationId: The unique identifier for the invitation to accept.
    ///   - masterAccount: (Deprecated) The Amazon Web Services account ID for the account that sent the invitation. This property has been replaced by the administratorAccountId property and is retained only for backward compatibility.
    ///   - logger: Logger use during operation
    @inlinable
    public func acceptInvitation(
        administratorAccountId: String? = nil,
        invitationId: String? = nil,
        masterAccount: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> AcceptInvitationResponse {
        let input = AcceptInvitationRequest(
            administratorAccountId: administratorAccountId, 
            invitationId: invitationId, 
            masterAccount: masterAccount
        )
        return try await self.acceptInvitation(input, logger: logger)
    }

    /// Retrieves information about one or more custom data identifiers.
    @Sendable
    @inlinable
    public func batchGetCustomDataIdentifiers(_ input: BatchGetCustomDataIdentifiersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchGetCustomDataIdentifiersResponse {
        try await self.client.execute(
            operation: "BatchGetCustomDataIdentifiers", 
            path: "/custom-data-identifiers/get", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about one or more custom data identifiers.
    ///
    /// Parameters:
    ///   - ids: An array of custom data identifier IDs, one for each custom data identifier to retrieve information about.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchGetCustomDataIdentifiers(
        ids: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchGetCustomDataIdentifiersResponse {
        let input = BatchGetCustomDataIdentifiersRequest(
            ids: ids
        )
        return try await self.batchGetCustomDataIdentifiers(input, logger: logger)
    }

    /// Changes the status of automated sensitive data discovery for one or more accounts.
    @Sendable
    @inlinable
    public func batchUpdateAutomatedDiscoveryAccounts(_ input: BatchUpdateAutomatedDiscoveryAccountsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> BatchUpdateAutomatedDiscoveryAccountsResponse {
        try await self.client.execute(
            operation: "BatchUpdateAutomatedDiscoveryAccounts", 
            path: "/automated-discovery/accounts", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Changes the status of automated sensitive data discovery for one or more accounts.
    ///
    /// Parameters:
    ///   - accounts: An array of objects, one for each account to change the status of automated sensitive data discovery for. Each object specifies the Amazon Web Services account ID for an account and a new status for that account.
    ///   - logger: Logger use during operation
    @inlinable
    public func batchUpdateAutomatedDiscoveryAccounts(
        accounts: [AutomatedDiscoveryAccountUpdate]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> BatchUpdateAutomatedDiscoveryAccountsResponse {
        let input = BatchUpdateAutomatedDiscoveryAccountsRequest(
            accounts: accounts
        )
        return try await self.batchUpdateAutomatedDiscoveryAccounts(input, logger: logger)
    }

    /// Creates and defines the settings for an allow list.
    @Sendable
    @inlinable
    public func createAllowList(_ input: CreateAllowListRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateAllowListResponse {
        try await self.client.execute(
            operation: "CreateAllowList", 
            path: "/allow-lists", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates and defines the settings for an allow list.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive token that you provide to ensure the idempotency of the request.
    ///   - criteria: The criteria that specify the text or text pattern to ignore. The criteria can be the location and name of an S3 object that lists specific text to ignore (s3WordsList), or a regular expression (regex) that defines a text pattern to ignore.
    ///   - description: A custom description of the allow list. The description can contain as many as 512 characters.
    ///   - name: A custom name for the allow list. The name can contain as many as 128 characters.
    ///   - tags: A map of key-value pairs that specifies the tags to associate with the allow list. An allow list can have a maximum of 50 tags. Each tag consists of a tag key and an associated tag value. The maximum length of a tag key is 128 characters. The maximum length of a tag value is 256 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func createAllowList(
        clientToken: String? = nil,
        criteria: AllowListCriteria? = nil,
        description: String? = nil,
        name: String? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateAllowListResponse {
        let input = CreateAllowListRequest(
            clientToken: clientToken, 
            criteria: criteria, 
            description: description, 
            name: name, 
            tags: tags
        )
        return try await self.createAllowList(input, logger: logger)
    }

    /// Creates and defines the settings for a classification job.
    @Sendable
    @inlinable
    public func createClassificationJob(_ input: CreateClassificationJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateClassificationJobResponse {
        try await self.client.execute(
            operation: "CreateClassificationJob", 
            path: "/jobs", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates and defines the settings for a classification job.
    ///
    /// Parameters:
    ///   - allowListIds: An array of unique identifiers, one for each allow list for the job to use when it analyzes data.
    ///   - clientToken: A unique, case-sensitive token that you provide to ensure the idempotency of the request.
    ///   - customDataIdentifierIds: An array of unique identifiers, one for each custom data identifier for the job to use when it analyzes data. To use only managed data identifiers, don't specify a value for this property and specify a value other than NONE for the managedDataIdentifierSelector property.
    ///   - description: A custom description of the job. The description can contain as many as 200 characters.
    ///   - initialRun: For a recurring job, specifies whether to analyze all existing, eligible objects immediately after the job is created (true). To analyze only those objects that are created or changed after you create the job and before the job's first scheduled run, set this value to false. If you configure the job to run only once, don't specify a value for this property.
    ///   - jobType: The schedule for running the job. Valid values are: ONE_TIME - Run the job only once. If you specify this value, don't specify a value for the scheduleFrequency property. SCHEDULED - Run the job on a daily, weekly, or monthly basis. If you specify this value, use the scheduleFrequency property to specify the recurrence pattern for the job.
    ///   - managedDataIdentifierIds: An array of unique identifiers, one for each managed data identifier for the job to include (use) or exclude (not use) when it analyzes data. Inclusion or exclusion depends on the managed data identifier selection type that you specify for the job (managedDataIdentifierSelector). To retrieve a list of valid values for this property, use the ListManagedDataIdentifiers operation.
    ///   - managedDataIdentifierSelector: The selection type to apply when determining which managed data identifiers the job uses to analyze data. Valid values are: ALL - Use all managed data identifiers. If you specify this value, don't specify any values for the managedDataIdentifierIds property. EXCLUDE - Use all managed data identifiers except the ones specified by the managedDataIdentifierIds property. INCLUDE - Use only the managed data identifiers specified by the managedDataIdentifierIds property. NONE - Don't use any managed data identifiers. If you specify this value, specify at least one value for the customDataIdentifierIds property and don't specify any values for the managedDataIdentifierIds property. RECOMMENDED (default) - Use the recommended set of managed data identifiers. If you specify this value, don't specify any values for the managedDataIdentifierIds property. If you don't specify a value for this property, the job uses the recommended set of managed data identifiers. If the job is a recurring job and you specify ALL or EXCLUDE, each job run automatically uses new managed data identifiers that are released. If you don't specify a value for this property or you specify RECOMMENDED for a recurring job, each job run automatically uses all the managed data identifiers that are in the recommended set when the run starts. To learn about individual managed data identifiers or determine which ones are in the recommended set, see Using managed data identifiers or Recommended managed data identifiers in the Amazon Macie User Guide.
    ///   - name: A custom name for the job. The name can contain as many as 500 characters.
    ///   - s3JobDefinition: The S3 buckets that contain the objects to analyze, and the scope of that analysis.
    ///   - samplingPercentage: The sampling depth, as a percentage, for the job to apply when processing objects. This value determines the percentage of eligible objects that the job analyzes. If this value is less than 100, Amazon Macie selects the objects to analyze at random, up to the specified percentage, and analyzes all the data in those objects.
    ///   - scheduleFrequency: The recurrence pattern for running the job. To run the job only once, don't specify a value for this property and set the value for the jobType property to ONE_TIME.
    ///   - tags: A map of key-value pairs that specifies the tags to associate with the job. A job can have a maximum of 50 tags. Each tag consists of a tag key and an associated tag value. The maximum length of a tag key is 128 characters. The maximum length of a tag value is 256 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func createClassificationJob(
        allowListIds: [String]? = nil,
        clientToken: String? = nil,
        customDataIdentifierIds: [String]? = nil,
        description: String? = nil,
        initialRun: Bool? = nil,
        jobType: JobType? = nil,
        managedDataIdentifierIds: [String]? = nil,
        managedDataIdentifierSelector: ManagedDataIdentifierSelector? = nil,
        name: String? = nil,
        s3JobDefinition: S3JobDefinition? = nil,
        samplingPercentage: Int? = nil,
        scheduleFrequency: JobScheduleFrequency? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateClassificationJobResponse {
        let input = CreateClassificationJobRequest(
            allowListIds: allowListIds, 
            clientToken: clientToken, 
            customDataIdentifierIds: customDataIdentifierIds, 
            description: description, 
            initialRun: initialRun, 
            jobType: jobType, 
            managedDataIdentifierIds: managedDataIdentifierIds, 
            managedDataIdentifierSelector: managedDataIdentifierSelector, 
            name: name, 
            s3JobDefinition: s3JobDefinition, 
            samplingPercentage: samplingPercentage, 
            scheduleFrequency: scheduleFrequency, 
            tags: tags
        )
        return try await self.createClassificationJob(input, logger: logger)
    }

    /// Creates and defines the criteria and other settings for a custom data identifier.
    @Sendable
    @inlinable
    public func createCustomDataIdentifier(_ input: CreateCustomDataIdentifierRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateCustomDataIdentifierResponse {
        try await self.client.execute(
            operation: "CreateCustomDataIdentifier", 
            path: "/custom-data-identifiers", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates and defines the criteria and other settings for a custom data identifier.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive token that you provide to ensure the idempotency of the request.
    ///   - description: A custom description of the custom data identifier. The description can contain as many as 512 characters. We strongly recommend that you avoid including any sensitive data in the description of a custom data identifier. Other users of your account might be able to see this description, depending on the actions that they're allowed to perform in Amazon Macie.
    ///   - ignoreWords: An array that lists specific character sequences (ignore words) to exclude from the results. If the text matched by the regular expression contains any string in this array, Amazon Macie ignores it. The array can contain as many as 10 ignore words. Each ignore word can contain 4-90 UTF-8 characters. Ignore words are case sensitive.
    ///   - keywords: An array that lists specific character sequences (keywords), one of which must precede and be within proximity (maximumMatchDistance) of the regular expression to match. The array can contain as many as 50 keywords. Each keyword can contain 3-90 UTF-8 characters. Keywords aren't case sensitive.
    ///   - maximumMatchDistance: The maximum number of characters that can exist between the end of at least one complete character sequence specified by the keywords array and the end of the text that matches the regex pattern. If a complete keyword precedes all the text that matches the pattern and the keyword is within the specified distance, Amazon Macie includes the result. The distance can be 1-300 characters. The default value is 50.
    ///   - name: A custom name for the custom data identifier. The name can contain as many as 128 characters. We strongly recommend that you avoid including any sensitive data in the name of a custom data identifier. Other users of your account might be able to see this name, depending on the actions that they're allowed to perform in Amazon Macie.
    ///   - regex: The regular expression (regex) that defines the pattern to match. The expression can contain as many as 512 characters.
    ///   - severityLevels: The severity to assign to findings that the custom data identifier produces, based on the number of occurrences of text that match the custom data identifier's detection criteria. You can specify as many as three SeverityLevel objects in this array, one for each severity: LOW, MEDIUM, or HIGH. If you specify more than one, the occurrences thresholds must be in ascending order by severity, moving from LOW to HIGH. For example, 1 for LOW, 50 for MEDIUM, and 100 for HIGH. If an S3 object contains fewer occurrences than the lowest specified threshold, Amazon Macie doesn't create a finding. If you don't specify any values for this array, Macie creates findings for S3 objects that contain at least one occurrence of text that matches the detection criteria, and Macie assigns the MEDIUM severity to those findings.
    ///   - tags: A map of key-value pairs that specifies the tags to associate with the custom data identifier. A custom data identifier can have a maximum of 50 tags. Each tag consists of a tag key and an associated tag value. The maximum length of a tag key is 128 characters. The maximum length of a tag value is 256 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func createCustomDataIdentifier(
        clientToken: String? = CreateCustomDataIdentifierRequest.idempotencyToken(),
        description: String? = nil,
        ignoreWords: [String]? = nil,
        keywords: [String]? = nil,
        maximumMatchDistance: Int? = nil,
        name: String? = nil,
        regex: String? = nil,
        severityLevels: [SeverityLevel]? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateCustomDataIdentifierResponse {
        let input = CreateCustomDataIdentifierRequest(
            clientToken: clientToken, 
            description: description, 
            ignoreWords: ignoreWords, 
            keywords: keywords, 
            maximumMatchDistance: maximumMatchDistance, 
            name: name, 
            regex: regex, 
            severityLevels: severityLevels, 
            tags: tags
        )
        return try await self.createCustomDataIdentifier(input, logger: logger)
    }

    /// Creates and defines the criteria and other settings for a findings filter.
    @Sendable
    @inlinable
    public func createFindingsFilter(_ input: CreateFindingsFilterRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateFindingsFilterResponse {
        try await self.client.execute(
            operation: "CreateFindingsFilter", 
            path: "/findingsfilters", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates and defines the criteria and other settings for a findings filter.
    ///
    /// Parameters:
    ///   - action: The action to perform on findings that match the filter criteria (findingCriteria). Valid values are: ARCHIVE, suppress (automatically archive) the findings; and, NOOP, don't perform any action on the findings.
    ///   - clientToken: A unique, case-sensitive token that you provide to ensure the idempotency of the request.
    ///   - description: A custom description of the filter. The description can contain as many as 512 characters. We strongly recommend that you avoid including any sensitive data in the description of a filter. Other users of your account might be able to see this description, depending on the actions that they're allowed to perform in Amazon Macie.
    ///   - findingCriteria: The criteria to use to filter findings.
    ///   - name: A custom name for the filter. The name must contain at least 3 characters and can contain as many as 64 characters. We strongly recommend that you avoid including any sensitive data in the name of a filter. Other users of your account might be able to see this name, depending on the actions that they're allowed to perform in Amazon Macie.
    ///   - position: The position of the filter in the list of saved filters on the Amazon Macie console. This value also determines the order in which the filter is applied to findings, relative to other filters that are also applied to the findings.
    ///   - tags: A map of key-value pairs that specifies the tags to associate with the filter. A findings filter can have a maximum of 50 tags. Each tag consists of a tag key and an associated tag value. The maximum length of a tag key is 128 characters. The maximum length of a tag value is 256 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func createFindingsFilter(
        action: FindingsFilterAction? = nil,
        clientToken: String? = CreateFindingsFilterRequest.idempotencyToken(),
        description: String? = nil,
        findingCriteria: FindingCriteria? = nil,
        name: String? = nil,
        position: Int? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateFindingsFilterResponse {
        let input = CreateFindingsFilterRequest(
            action: action, 
            clientToken: clientToken, 
            description: description, 
            findingCriteria: findingCriteria, 
            name: name, 
            position: position, 
            tags: tags
        )
        return try await self.createFindingsFilter(input, logger: logger)
    }

    /// Sends an Amazon Macie membership invitation to one or more accounts.
    @Sendable
    @inlinable
    public func createInvitations(_ input: CreateInvitationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateInvitationsResponse {
        try await self.client.execute(
            operation: "CreateInvitations", 
            path: "/invitations", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Sends an Amazon Macie membership invitation to one or more accounts.
    ///
    /// Parameters:
    ///   - accountIds: An array that lists Amazon Web Services account IDs, one for each account to send the invitation to.
    ///   - disableEmailNotification: Specifies whether to send the invitation as an email message. If this value is false, Amazon Macie sends the invitation (as an email message) to the email address that you specified for the recipient's account when you associated the account with your account. The default value is false.
    ///   - message: Custom text to include in the email message that contains the invitation. The text can contain as many as 80 alphanumeric characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func createInvitations(
        accountIds: [String]? = nil,
        disableEmailNotification: Bool? = nil,
        message: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateInvitationsResponse {
        let input = CreateInvitationsRequest(
            accountIds: accountIds, 
            disableEmailNotification: disableEmailNotification, 
            message: message
        )
        return try await self.createInvitations(input, logger: logger)
    }

    /// Associates an account with an Amazon Macie administrator account.
    @Sendable
    @inlinable
    public func createMember(_ input: CreateMemberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateMemberResponse {
        try await self.client.execute(
            operation: "CreateMember", 
            path: "/members", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Associates an account with an Amazon Macie administrator account.
    ///
    /// Parameters:
    ///   - account: The details of the account to associate with the administrator account.
    ///   - tags: A map of key-value pairs that specifies the tags to associate with the account in Amazon Macie. An account can have a maximum of 50 tags. Each tag consists of a tag key and an associated tag value. The maximum length of a tag key is 128 characters. The maximum length of a tag value is 256 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func createMember(
        account: AccountDetail? = nil,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateMemberResponse {
        let input = CreateMemberRequest(
            account: account, 
            tags: tags
        )
        return try await self.createMember(input, logger: logger)
    }

    /// Creates sample findings.
    @Sendable
    @inlinable
    public func createSampleFindings(_ input: CreateSampleFindingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> CreateSampleFindingsResponse {
        try await self.client.execute(
            operation: "CreateSampleFindings", 
            path: "/findings/sample", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Creates sample findings.
    ///
    /// Parameters:
    ///   - findingTypes: An array of finding types, one for each type of sample finding to create. To create a sample of every type of finding that Amazon Macie supports, don't include this array in your request.
    ///   - logger: Logger use during operation
    @inlinable
    public func createSampleFindings(
        findingTypes: [FindingType]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> CreateSampleFindingsResponse {
        let input = CreateSampleFindingsRequest(
            findingTypes: findingTypes
        )
        return try await self.createSampleFindings(input, logger: logger)
    }

    /// Declines Amazon Macie membership invitations that were received from specific accounts.
    @Sendable
    @inlinable
    public func declineInvitations(_ input: DeclineInvitationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeclineInvitationsResponse {
        try await self.client.execute(
            operation: "DeclineInvitations", 
            path: "/invitations/decline", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Declines Amazon Macie membership invitations that were received from specific accounts.
    ///
    /// Parameters:
    ///   - accountIds: An array that lists Amazon Web Services account IDs, one for each account that sent an invitation to decline.
    ///   - logger: Logger use during operation
    @inlinable
    public func declineInvitations(
        accountIds: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeclineInvitationsResponse {
        let input = DeclineInvitationsRequest(
            accountIds: accountIds
        )
        return try await self.declineInvitations(input, logger: logger)
    }

    /// Deletes an allow list.
    @Sendable
    @inlinable
    public func deleteAllowList(_ input: DeleteAllowListRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteAllowListResponse {
        try await self.client.execute(
            operation: "DeleteAllowList", 
            path: "/allow-lists/{id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes an allow list.
    ///
    /// Parameters:
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - ignoreJobChecks: Specifies whether to force deletion of the allow list, even if active classification jobs are configured to use the list. When you try to delete an allow list, Amazon Macie checks for classification jobs that use the list and have a status other than COMPLETE or CANCELLED. By default, Macie rejects your request if any jobs meet these criteria. To skip these checks and delete the list, set this value to true. To delete the list only if no active jobs are configured to use it, set this value to false.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteAllowList(
        id: String,
        ignoreJobChecks: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteAllowListResponse {
        let input = DeleteAllowListRequest(
            id: id, 
            ignoreJobChecks: ignoreJobChecks
        )
        return try await self.deleteAllowList(input, logger: logger)
    }

    /// Soft deletes a custom data identifier.
    @Sendable
    @inlinable
    public func deleteCustomDataIdentifier(_ input: DeleteCustomDataIdentifierRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteCustomDataIdentifierResponse {
        try await self.client.execute(
            operation: "DeleteCustomDataIdentifier", 
            path: "/custom-data-identifiers/{id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Soft deletes a custom data identifier.
    ///
    /// Parameters:
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteCustomDataIdentifier(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteCustomDataIdentifierResponse {
        let input = DeleteCustomDataIdentifierRequest(
            id: id
        )
        return try await self.deleteCustomDataIdentifier(input, logger: logger)
    }

    /// Deletes a findings filter.
    @Sendable
    @inlinable
    public func deleteFindingsFilter(_ input: DeleteFindingsFilterRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteFindingsFilterResponse {
        try await self.client.execute(
            operation: "DeleteFindingsFilter", 
            path: "/findingsfilters/{id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes a findings filter.
    ///
    /// Parameters:
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteFindingsFilter(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteFindingsFilterResponse {
        let input = DeleteFindingsFilterRequest(
            id: id
        )
        return try await self.deleteFindingsFilter(input, logger: logger)
    }

    /// Deletes Amazon Macie membership invitations that were received from specific accounts.
    @Sendable
    @inlinable
    public func deleteInvitations(_ input: DeleteInvitationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteInvitationsResponse {
        try await self.client.execute(
            operation: "DeleteInvitations", 
            path: "/invitations/delete", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes Amazon Macie membership invitations that were received from specific accounts.
    ///
    /// Parameters:
    ///   - accountIds: An array that lists Amazon Web Services account IDs, one for each account that sent an invitation to delete.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteInvitations(
        accountIds: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteInvitationsResponse {
        let input = DeleteInvitationsRequest(
            accountIds: accountIds
        )
        return try await self.deleteInvitations(input, logger: logger)
    }

    /// Deletes the association between an Amazon Macie administrator account and an account.
    @Sendable
    @inlinable
    public func deleteMember(_ input: DeleteMemberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DeleteMemberResponse {
        try await self.client.execute(
            operation: "DeleteMember", 
            path: "/members/{id}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Deletes the association between an Amazon Macie administrator account and an account.
    ///
    /// Parameters:
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func deleteMember(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DeleteMemberResponse {
        let input = DeleteMemberRequest(
            id: id
        )
        return try await self.deleteMember(input, logger: logger)
    }

    /// Retrieves (queries) statistical data and other information about one or more S3 buckets that Amazon Macie monitors and analyzes for an account.
    @Sendable
    @inlinable
    public func describeBuckets(_ input: DescribeBucketsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeBucketsResponse {
        try await self.client.execute(
            operation: "DescribeBuckets", 
            path: "/datasources/s3", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) statistical data and other information about one or more S3 buckets that Amazon Macie monitors and analyzes for an account.
    ///
    /// Parameters:
    ///   - criteria: The criteria to use to filter the query results.
    ///   - maxResults: The maximum number of items to include in each page of the response. The default value is 50.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - sortCriteria: The criteria to use to sort the query results.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeBuckets(
        criteria: [String: BucketCriteriaAdditionalProperties]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sortCriteria: BucketSortCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeBucketsResponse {
        let input = DescribeBucketsRequest(
            criteria: criteria, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sortCriteria: sortCriteria
        )
        return try await self.describeBuckets(input, logger: logger)
    }

    /// Retrieves the status and settings for a classification job.
    @Sendable
    @inlinable
    public func describeClassificationJob(_ input: DescribeClassificationJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeClassificationJobResponse {
        try await self.client.execute(
            operation: "DescribeClassificationJob", 
            path: "/jobs/{jobId}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the status and settings for a classification job.
    ///
    /// Parameters:
    ///   - jobId: The unique identifier for the classification job.
    ///   - logger: Logger use during operation
    @inlinable
    public func describeClassificationJob(
        jobId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeClassificationJobResponse {
        let input = DescribeClassificationJobRequest(
            jobId: jobId
        )
        return try await self.describeClassificationJob(input, logger: logger)
    }

    /// Retrieves the Amazon Macie configuration settings for an organization in Organizations.
    @Sendable
    @inlinable
    public func describeOrganizationConfiguration(_ input: DescribeOrganizationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DescribeOrganizationConfigurationResponse {
        try await self.client.execute(
            operation: "DescribeOrganizationConfiguration", 
            path: "/admin/configuration", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the Amazon Macie configuration settings for an organization in Organizations.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func describeOrganizationConfiguration(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DescribeOrganizationConfigurationResponse {
        let input = DescribeOrganizationConfigurationRequest(
        )
        return try await self.describeOrganizationConfiguration(input, logger: logger)
    }

    /// Disables Amazon Macie and deletes all settings and resources for a Macie account.
    @Sendable
    @inlinable
    public func disableMacie(_ input: DisableMacieRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisableMacieResponse {
        try await self.client.execute(
            operation: "DisableMacie", 
            path: "/macie", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables Amazon Macie and deletes all settings and resources for a Macie account.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func disableMacie(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisableMacieResponse {
        let input = DisableMacieRequest(
        )
        return try await self.disableMacie(input, logger: logger)
    }

    /// Disables an account as the delegated Amazon Macie administrator account for an organization in Organizations.
    @Sendable
    @inlinable
    public func disableOrganizationAdminAccount(_ input: DisableOrganizationAdminAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisableOrganizationAdminAccountResponse {
        try await self.client.execute(
            operation: "DisableOrganizationAdminAccount", 
            path: "/admin", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disables an account as the delegated Amazon Macie administrator account for an organization in Organizations.
    ///
    /// Parameters:
    ///   - adminAccountId: The Amazon Web Services account ID of the delegated Amazon Macie administrator account.
    ///   - logger: Logger use during operation
    @inlinable
    public func disableOrganizationAdminAccount(
        adminAccountId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisableOrganizationAdminAccountResponse {
        let input = DisableOrganizationAdminAccountRequest(
            adminAccountId: adminAccountId
        )
        return try await self.disableOrganizationAdminAccount(input, logger: logger)
    }

    /// Disassociates a member account from its Amazon Macie administrator account.
    @Sendable
    @inlinable
    public func disassociateFromAdministratorAccount(_ input: DisassociateFromAdministratorAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateFromAdministratorAccountResponse {
        try await self.client.execute(
            operation: "DisassociateFromAdministratorAccount", 
            path: "/administrator/disassociate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates a member account from its Amazon Macie administrator account.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateFromAdministratorAccount(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateFromAdministratorAccountResponse {
        let input = DisassociateFromAdministratorAccountRequest(
        )
        return try await self.disassociateFromAdministratorAccount(input, logger: logger)
    }

    /// (Deprecated) Disassociates a member account from its Amazon Macie administrator account. This operation has been replaced by the DisassociateFromAdministratorAccount operation.
    @Sendable
    @inlinable
    public func disassociateFromMasterAccount(_ input: DisassociateFromMasterAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateFromMasterAccountResponse {
        try await self.client.execute(
            operation: "DisassociateFromMasterAccount", 
            path: "/master/disassociate", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// (Deprecated) Disassociates a member account from its Amazon Macie administrator account. This operation has been replaced by the DisassociateFromAdministratorAccount operation.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateFromMasterAccount(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateFromMasterAccountResponse {
        let input = DisassociateFromMasterAccountRequest(
        )
        return try await self.disassociateFromMasterAccount(input, logger: logger)
    }

    /// Disassociates an Amazon Macie administrator account from a member account.
    @Sendable
    @inlinable
    public func disassociateMember(_ input: DisassociateMemberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> DisassociateMemberResponse {
        try await self.client.execute(
            operation: "DisassociateMember", 
            path: "/members/disassociate/{id}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Disassociates an Amazon Macie administrator account from a member account.
    ///
    /// Parameters:
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func disassociateMember(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> DisassociateMemberResponse {
        let input = DisassociateMemberRequest(
            id: id
        )
        return try await self.disassociateMember(input, logger: logger)
    }

    /// Enables Amazon Macie and specifies the configuration settings for a Macie account.
    @Sendable
    @inlinable
    public func enableMacie(_ input: EnableMacieRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> EnableMacieResponse {
        try await self.client.execute(
            operation: "EnableMacie", 
            path: "/macie", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables Amazon Macie and specifies the configuration settings for a Macie account.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive token that you provide to ensure the idempotency of the request.
    ///   - findingPublishingFrequency: Specifies how often to publish updates to policy findings for the account. This includes publishing updates to Security Hub and Amazon EventBridge (formerly Amazon CloudWatch Events).
    ///   - status: Specifies the new status for the account. To enable Amazon Macie and start all Macie activities for the account, set this value to ENABLED.
    ///   - logger: Logger use during operation
    @inlinable
    public func enableMacie(
        clientToken: String? = EnableMacieRequest.idempotencyToken(),
        findingPublishingFrequency: FindingPublishingFrequency? = nil,
        status: MacieStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> EnableMacieResponse {
        let input = EnableMacieRequest(
            clientToken: clientToken, 
            findingPublishingFrequency: findingPublishingFrequency, 
            status: status
        )
        return try await self.enableMacie(input, logger: logger)
    }

    /// Designates an account as the delegated Amazon Macie administrator account for an organization in Organizations.
    @Sendable
    @inlinable
    public func enableOrganizationAdminAccount(_ input: EnableOrganizationAdminAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> EnableOrganizationAdminAccountResponse {
        try await self.client.execute(
            operation: "EnableOrganizationAdminAccount", 
            path: "/admin", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Designates an account as the delegated Amazon Macie administrator account for an organization in Organizations.
    ///
    /// Parameters:
    ///   - adminAccountId: The Amazon Web Services account ID for the account to designate as the delegated Amazon Macie administrator account for the organization.
    ///   - clientToken: A unique, case-sensitive token that you provide to ensure the idempotency of the request.
    ///   - logger: Logger use during operation
    @inlinable
    public func enableOrganizationAdminAccount(
        adminAccountId: String? = nil,
        clientToken: String? = EnableOrganizationAdminAccountRequest.idempotencyToken(),
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> EnableOrganizationAdminAccountResponse {
        let input = EnableOrganizationAdminAccountRequest(
            adminAccountId: adminAccountId, 
            clientToken: clientToken
        )
        return try await self.enableOrganizationAdminAccount(input, logger: logger)
    }

    /// Retrieves information about the Amazon Macie administrator account for an account.
    @Sendable
    @inlinable
    public func getAdministratorAccount(_ input: GetAdministratorAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAdministratorAccountResponse {
        try await self.client.execute(
            operation: "GetAdministratorAccount", 
            path: "/administrator", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the Amazon Macie administrator account for an account.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getAdministratorAccount(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAdministratorAccountResponse {
        let input = GetAdministratorAccountRequest(
        )
        return try await self.getAdministratorAccount(input, logger: logger)
    }

    /// Retrieves the settings and status of an allow list.
    @Sendable
    @inlinable
    public func getAllowList(_ input: GetAllowListRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAllowListResponse {
        try await self.client.execute(
            operation: "GetAllowList", 
            path: "/allow-lists/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the settings and status of an allow list.
    ///
    /// Parameters:
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func getAllowList(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAllowListResponse {
        let input = GetAllowListRequest(
            id: id
        )
        return try await self.getAllowList(input, logger: logger)
    }

    /// Retrieves the configuration settings and status of automated sensitive data discovery for an organization or standalone account.
    @Sendable
    @inlinable
    public func getAutomatedDiscoveryConfiguration(_ input: GetAutomatedDiscoveryConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetAutomatedDiscoveryConfigurationResponse {
        try await self.client.execute(
            operation: "GetAutomatedDiscoveryConfiguration", 
            path: "/automated-discovery/configuration", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the configuration settings and status of automated sensitive data discovery for an organization or standalone account.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getAutomatedDiscoveryConfiguration(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetAutomatedDiscoveryConfigurationResponse {
        let input = GetAutomatedDiscoveryConfigurationRequest(
        )
        return try await self.getAutomatedDiscoveryConfiguration(input, logger: logger)
    }

    /// Retrieves (queries) aggregated statistical data about all the S3 buckets that Amazon Macie monitors and analyzes for an account.
    @Sendable
    @inlinable
    public func getBucketStatistics(_ input: GetBucketStatisticsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetBucketStatisticsResponse {
        try await self.client.execute(
            operation: "GetBucketStatistics", 
            path: "/datasources/s3/statistics", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) aggregated statistical data about all the S3 buckets that Amazon Macie monitors and analyzes for an account.
    ///
    /// Parameters:
    ///   - accountId: The unique identifier for the Amazon Web Services account.
    ///   - logger: Logger use during operation
    @inlinable
    public func getBucketStatistics(
        accountId: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetBucketStatisticsResponse {
        let input = GetBucketStatisticsRequest(
            accountId: accountId
        )
        return try await self.getBucketStatistics(input, logger: logger)
    }

    /// Retrieves the configuration settings for storing data classification results.
    @Sendable
    @inlinable
    public func getClassificationExportConfiguration(_ input: GetClassificationExportConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetClassificationExportConfigurationResponse {
        try await self.client.execute(
            operation: "GetClassificationExportConfiguration", 
            path: "/classification-export-configuration", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the configuration settings for storing data classification results.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getClassificationExportConfiguration(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetClassificationExportConfigurationResponse {
        let input = GetClassificationExportConfigurationRequest(
        )
        return try await self.getClassificationExportConfiguration(input, logger: logger)
    }

    /// Retrieves the classification scope settings for an account.
    @Sendable
    @inlinable
    public func getClassificationScope(_ input: GetClassificationScopeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetClassificationScopeResponse {
        try await self.client.execute(
            operation: "GetClassificationScope", 
            path: "/classification-scopes/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the classification scope settings for an account.
    ///
    /// Parameters:
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func getClassificationScope(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetClassificationScopeResponse {
        let input = GetClassificationScopeRequest(
            id: id
        )
        return try await self.getClassificationScope(input, logger: logger)
    }

    /// Retrieves the criteria and other settings for a custom data identifier.
    @Sendable
    @inlinable
    public func getCustomDataIdentifier(_ input: GetCustomDataIdentifierRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetCustomDataIdentifierResponse {
        try await self.client.execute(
            operation: "GetCustomDataIdentifier", 
            path: "/custom-data-identifiers/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the criteria and other settings for a custom data identifier.
    ///
    /// Parameters:
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func getCustomDataIdentifier(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetCustomDataIdentifierResponse {
        let input = GetCustomDataIdentifierRequest(
            id: id
        )
        return try await self.getCustomDataIdentifier(input, logger: logger)
    }

    /// Retrieves (queries) aggregated statistical data about findings.
    @Sendable
    @inlinable
    public func getFindingStatistics(_ input: GetFindingStatisticsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetFindingStatisticsResponse {
        try await self.client.execute(
            operation: "GetFindingStatistics", 
            path: "/findings/statistics", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) aggregated statistical data about findings.
    ///
    /// Parameters:
    ///   - findingCriteria: The criteria to use to filter the query results.
    ///   - groupBy: The finding property to use to group the query results. Valid values are: classificationDetails.jobId - The unique identifier for the classification job that produced the finding. resourcesAffected.s3Bucket.name - The name of the S3 bucket that the finding applies to. severity.description - The severity level of the finding, such as High or Medium. type - The type of finding, such as Policy:IAMUser/S3BucketPublic and SensitiveData:S3Object/Personal.
    ///   - size: The maximum number of items to include in each page of the response.
    ///   - sortCriteria: The criteria to use to sort the query results.
    ///   - logger: Logger use during operation
    @inlinable
    public func getFindingStatistics(
        findingCriteria: FindingCriteria? = nil,
        groupBy: GroupBy? = nil,
        size: Int? = nil,
        sortCriteria: FindingStatisticsSortCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFindingStatisticsResponse {
        let input = GetFindingStatisticsRequest(
            findingCriteria: findingCriteria, 
            groupBy: groupBy, 
            size: size, 
            sortCriteria: sortCriteria
        )
        return try await self.getFindingStatistics(input, logger: logger)
    }

    /// Retrieves the details of one or more findings.
    @Sendable
    @inlinable
    public func getFindings(_ input: GetFindingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetFindingsResponse {
        try await self.client.execute(
            operation: "GetFindings", 
            path: "/findings/describe", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the details of one or more findings.
    ///
    /// Parameters:
    ///   - findingIds: An array of strings that lists the unique identifiers for the findings to retrieve. You can specify as many as 50 unique identifiers in this array.
    ///   - sortCriteria: The criteria for sorting the results of the request.
    ///   - logger: Logger use during operation
    @inlinable
    public func getFindings(
        findingIds: [String]? = nil,
        sortCriteria: SortCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFindingsResponse {
        let input = GetFindingsRequest(
            findingIds: findingIds, 
            sortCriteria: sortCriteria
        )
        return try await self.getFindings(input, logger: logger)
    }

    /// Retrieves the criteria and other settings for a findings filter.
    @Sendable
    @inlinable
    public func getFindingsFilter(_ input: GetFindingsFilterRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetFindingsFilterResponse {
        try await self.client.execute(
            operation: "GetFindingsFilter", 
            path: "/findingsfilters/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the criteria and other settings for a findings filter.
    ///
    /// Parameters:
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func getFindingsFilter(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFindingsFilterResponse {
        let input = GetFindingsFilterRequest(
            id: id
        )
        return try await self.getFindingsFilter(input, logger: logger)
    }

    /// Retrieves the configuration settings for publishing findings to Security Hub.
    @Sendable
    @inlinable
    public func getFindingsPublicationConfiguration(_ input: GetFindingsPublicationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetFindingsPublicationConfigurationResponse {
        try await self.client.execute(
            operation: "GetFindingsPublicationConfiguration", 
            path: "/findings-publication-configuration", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the configuration settings for publishing findings to Security Hub.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getFindingsPublicationConfiguration(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetFindingsPublicationConfigurationResponse {
        let input = GetFindingsPublicationConfigurationRequest(
        )
        return try await self.getFindingsPublicationConfiguration(input, logger: logger)
    }

    /// Retrieves the count of Amazon Macie membership invitations that were received by an account.
    @Sendable
    @inlinable
    public func getInvitationsCount(_ input: GetInvitationsCountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetInvitationsCountResponse {
        try await self.client.execute(
            operation: "GetInvitationsCount", 
            path: "/invitations/count", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the count of Amazon Macie membership invitations that were received by an account.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getInvitationsCount(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetInvitationsCountResponse {
        let input = GetInvitationsCountRequest(
        )
        return try await self.getInvitationsCount(input, logger: logger)
    }

    /// Retrieves the status and configuration settings for an Amazon Macie account.
    @Sendable
    @inlinable
    public func getMacieSession(_ input: GetMacieSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMacieSessionResponse {
        try await self.client.execute(
            operation: "GetMacieSession", 
            path: "/macie", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the status and configuration settings for an Amazon Macie account.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getMacieSession(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMacieSessionResponse {
        let input = GetMacieSessionRequest(
        )
        return try await self.getMacieSession(input, logger: logger)
    }

    /// (Deprecated) Retrieves information about the Amazon Macie administrator account for an account. This operation has been replaced by the GetAdministratorAccount operation.
    @Sendable
    @inlinable
    public func getMasterAccount(_ input: GetMasterAccountRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMasterAccountResponse {
        try await self.client.execute(
            operation: "GetMasterAccount", 
            path: "/master", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// (Deprecated) Retrieves information about the Amazon Macie administrator account for an account. This operation has been replaced by the GetAdministratorAccount operation.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getMasterAccount(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMasterAccountResponse {
        let input = GetMasterAccountRequest(
        )
        return try await self.getMasterAccount(input, logger: logger)
    }

    /// Retrieves information about an account that's associated with an Amazon Macie administrator account.
    @Sendable
    @inlinable
    public func getMember(_ input: GetMemberRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetMemberResponse {
        try await self.client.execute(
            operation: "GetMember", 
            path: "/members/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about an account that's associated with an Amazon Macie administrator account.
    ///
    /// Parameters:
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func getMember(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetMemberResponse {
        let input = GetMemberRequest(
            id: id
        )
        return try await self.getMember(input, logger: logger)
    }

    /// Retrieves (queries) sensitive data discovery statistics and the sensitivity score for an S3 bucket.
    @Sendable
    @inlinable
    public func getResourceProfile(_ input: GetResourceProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetResourceProfileResponse {
        try await self.client.execute(
            operation: "GetResourceProfile", 
            path: "/resource-profiles", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) sensitive data discovery statistics and the sensitivity score for an S3 bucket.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the S3 bucket that the request applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func getResourceProfile(
        resourceArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetResourceProfileResponse {
        let input = GetResourceProfileRequest(
            resourceArn: resourceArn
        )
        return try await self.getResourceProfile(input, logger: logger)
    }

    /// Retrieves the status and configuration settings for retrieving occurrences of sensitive data reported by findings.
    @Sendable
    @inlinable
    public func getRevealConfiguration(_ input: GetRevealConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetRevealConfigurationResponse {
        try await self.client.execute(
            operation: "GetRevealConfiguration", 
            path: "/reveal-configuration", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the status and configuration settings for retrieving occurrences of sensitive data reported by findings.
    ///
    /// Parameters:
    ///   - logger: Logger use during operation
    @inlinable
    public func getRevealConfiguration(
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetRevealConfigurationResponse {
        let input = GetRevealConfigurationRequest(
        )
        return try await self.getRevealConfiguration(input, logger: logger)
    }

    /// Retrieves occurrences of sensitive data reported by a finding.
    @Sendable
    @inlinable
    public func getSensitiveDataOccurrences(_ input: GetSensitiveDataOccurrencesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSensitiveDataOccurrencesResponse {
        try await self.client.execute(
            operation: "GetSensitiveDataOccurrences", 
            path: "/findings/{findingId}/reveal", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves occurrences of sensitive data reported by a finding.
    ///
    /// Parameters:
    ///   - findingId: The unique identifier for the finding.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSensitiveDataOccurrences(
        findingId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSensitiveDataOccurrencesResponse {
        let input = GetSensitiveDataOccurrencesRequest(
            findingId: findingId
        )
        return try await self.getSensitiveDataOccurrences(input, logger: logger)
    }

    /// Checks whether occurrences of sensitive data can be retrieved for a finding.
    @Sendable
    @inlinable
    public func getSensitiveDataOccurrencesAvailability(_ input: GetSensitiveDataOccurrencesAvailabilityRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSensitiveDataOccurrencesAvailabilityResponse {
        try await self.client.execute(
            operation: "GetSensitiveDataOccurrencesAvailability", 
            path: "/findings/{findingId}/reveal/availability", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Checks whether occurrences of sensitive data can be retrieved for a finding.
    ///
    /// Parameters:
    ///   - findingId: The unique identifier for the finding.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSensitiveDataOccurrencesAvailability(
        findingId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSensitiveDataOccurrencesAvailabilityResponse {
        let input = GetSensitiveDataOccurrencesAvailabilityRequest(
            findingId: findingId
        )
        return try await self.getSensitiveDataOccurrencesAvailability(input, logger: logger)
    }

    /// Retrieves the settings for the sensitivity inspection template for an account.
    @Sendable
    @inlinable
    public func getSensitivityInspectionTemplate(_ input: GetSensitivityInspectionTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetSensitivityInspectionTemplateResponse {
        try await self.client.execute(
            operation: "GetSensitivityInspectionTemplate", 
            path: "/templates/sensitivity-inspections/{id}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the settings for the sensitivity inspection template for an account.
    ///
    /// Parameters:
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func getSensitivityInspectionTemplate(
        id: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetSensitivityInspectionTemplateResponse {
        let input = GetSensitivityInspectionTemplateRequest(
            id: id
        )
        return try await self.getSensitivityInspectionTemplate(input, logger: logger)
    }

    /// Retrieves (queries) quotas and aggregated usage data for one or more accounts.
    @Sendable
    @inlinable
    public func getUsageStatistics(_ input: GetUsageStatisticsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetUsageStatisticsResponse {
        try await self.client.execute(
            operation: "GetUsageStatistics", 
            path: "/usage/statistics", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) quotas and aggregated usage data for one or more accounts.
    ///
    /// Parameters:
    ///   - filterBy: An array of objects, one for each condition to use to filter the query results. If you specify more than one condition, Amazon Macie uses an AND operator to join the conditions.
    ///   - maxResults: The maximum number of items to include in each page of the response.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - sortBy: The criteria to use to sort the query results.
    ///   - timeRange: The inclusive time period to query usage data for. Valid values are: MONTH_TO_DATE, for the current calendar month to date; and, PAST_30_DAYS, for the preceding 30 days. If you don't specify a value, Amazon Macie provides usage data for the preceding 30 days.
    ///   - logger: Logger use during operation
    @inlinable
    public func getUsageStatistics(
        filterBy: [UsageStatisticsFilter]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sortBy: UsageStatisticsSortBy? = nil,
        timeRange: TimeRange? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetUsageStatisticsResponse {
        let input = GetUsageStatisticsRequest(
            filterBy: filterBy, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sortBy: sortBy, 
            timeRange: timeRange
        )
        return try await self.getUsageStatistics(input, logger: logger)
    }

    /// Retrieves (queries) aggregated usage data for an account.
    @Sendable
    @inlinable
    public func getUsageTotals(_ input: GetUsageTotalsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> GetUsageTotalsResponse {
        try await self.client.execute(
            operation: "GetUsageTotals", 
            path: "/usage", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) aggregated usage data for an account.
    ///
    /// Parameters:
    ///   - timeRange: The inclusive time period to retrieve the data for. Valid values are: MONTH_TO_DATE, for the current calendar month to date; and, PAST_30_DAYS, for the preceding 30 days. If you don't specify a value for this parameter, Amazon Macie provides aggregated usage data for the preceding 30 days.
    ///   - logger: Logger use during operation
    @inlinable
    public func getUsageTotals(
        timeRange: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> GetUsageTotalsResponse {
        let input = GetUsageTotalsRequest(
            timeRange: timeRange
        )
        return try await self.getUsageTotals(input, logger: logger)
    }

    /// Retrieves a subset of information about all the allow lists for an account.
    @Sendable
    @inlinable
    public func listAllowLists(_ input: ListAllowListsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAllowListsResponse {
        try await self.client.execute(
            operation: "ListAllowLists", 
            path: "/allow-lists", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a subset of information about all the allow lists for an account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAllowLists(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAllowListsResponse {
        let input = ListAllowListsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAllowLists(input, logger: logger)
    }

    /// Retrieves the status of automated sensitive data discovery for one or more accounts.
    @Sendable
    @inlinable
    public func listAutomatedDiscoveryAccounts(_ input: ListAutomatedDiscoveryAccountsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListAutomatedDiscoveryAccountsResponse {
        try await self.client.execute(
            operation: "ListAutomatedDiscoveryAccounts", 
            path: "/automated-discovery/accounts", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the status of automated sensitive data discovery for one or more accounts.
    ///
    /// Parameters:
    ///   - accountIds: The Amazon Web Services account ID for each account, for as many as 50 accounts. To retrieve the status for multiple accounts, append the accountIds parameter and argument for each account, separated by an ampersand (&amp;). To retrieve the status for all the accounts in an organization, omit this parameter.
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func listAutomatedDiscoveryAccounts(
        accountIds: [String]? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListAutomatedDiscoveryAccountsResponse {
        let input = ListAutomatedDiscoveryAccountsRequest(
            accountIds: accountIds, 
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listAutomatedDiscoveryAccounts(input, logger: logger)
    }

    /// Retrieves a subset of information about one or more classification jobs.
    @Sendable
    @inlinable
    public func listClassificationJobs(_ input: ListClassificationJobsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListClassificationJobsResponse {
        try await self.client.execute(
            operation: "ListClassificationJobs", 
            path: "/jobs/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a subset of information about one or more classification jobs.
    ///
    /// Parameters:
    ///   - filterCriteria: The criteria to use to filter the results.
    ///   - maxResults: The maximum number of items to include in each page of the response.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - sortCriteria: The criteria to use to sort the results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listClassificationJobs(
        filterCriteria: ListJobsFilterCriteria? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sortCriteria: ListJobsSortCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListClassificationJobsResponse {
        let input = ListClassificationJobsRequest(
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sortCriteria: sortCriteria
        )
        return try await self.listClassificationJobs(input, logger: logger)
    }

    /// Retrieves a subset of information about the classification scope for an account.
    @Sendable
    @inlinable
    public func listClassificationScopes(_ input: ListClassificationScopesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListClassificationScopesResponse {
        try await self.client.execute(
            operation: "ListClassificationScopes", 
            path: "/classification-scopes", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a subset of information about the classification scope for an account.
    ///
    /// Parameters:
    ///   - name: The name of the classification scope to retrieve the unique identifier for.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func listClassificationScopes(
        name: String? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListClassificationScopesResponse {
        let input = ListClassificationScopesRequest(
            name: name, 
            nextToken: nextToken
        )
        return try await self.listClassificationScopes(input, logger: logger)
    }

    /// Retrieves a subset of information about the custom data identifiers for an account.
    @Sendable
    @inlinable
    public func listCustomDataIdentifiers(_ input: ListCustomDataIdentifiersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListCustomDataIdentifiersResponse {
        try await self.client.execute(
            operation: "ListCustomDataIdentifiers", 
            path: "/custom-data-identifiers/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a subset of information about the custom data identifiers for an account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of items to include in each page of the response.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func listCustomDataIdentifiers(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListCustomDataIdentifiersResponse {
        let input = ListCustomDataIdentifiersRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listCustomDataIdentifiers(input, logger: logger)
    }

    /// Retrieves a subset of information about one or more findings.
    @Sendable
    @inlinable
    public func listFindings(_ input: ListFindingsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListFindingsResponse {
        try await self.client.execute(
            operation: "ListFindings", 
            path: "/findings", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a subset of information about one or more findings.
    ///
    /// Parameters:
    ///   - findingCriteria: The criteria to use to filter the results.
    ///   - maxResults: The maximum number of items to include in each page of the response.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - sortCriteria: The criteria to use to sort the results.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFindings(
        findingCriteria: FindingCriteria? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sortCriteria: SortCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFindingsResponse {
        let input = ListFindingsRequest(
            findingCriteria: findingCriteria, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sortCriteria: sortCriteria
        )
        return try await self.listFindings(input, logger: logger)
    }

    /// Retrieves a subset of information about all the findings filters for an account.
    @Sendable
    @inlinable
    public func listFindingsFilters(_ input: ListFindingsFiltersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListFindingsFiltersResponse {
        try await self.client.execute(
            operation: "ListFindingsFilters", 
            path: "/findingsfilters", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a subset of information about all the findings filters for an account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func listFindingsFilters(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListFindingsFiltersResponse {
        let input = ListFindingsFiltersRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listFindingsFilters(input, logger: logger)
    }

    /// Retrieves information about Amazon Macie membership invitations that were received by an account.
    @Sendable
    @inlinable
    public func listInvitations(_ input: ListInvitationsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListInvitationsResponse {
        try await self.client.execute(
            operation: "ListInvitations", 
            path: "/invitations", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about Amazon Macie membership invitations that were received by an account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func listInvitations(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListInvitationsResponse {
        let input = ListInvitationsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listInvitations(input, logger: logger)
    }

    /// Retrieves information about all the managed data identifiers that Amazon Macie currently provides.
    @Sendable
    @inlinable
    public func listManagedDataIdentifiers(_ input: ListManagedDataIdentifiersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListManagedDataIdentifiersResponse {
        try await self.client.execute(
            operation: "ListManagedDataIdentifiers", 
            path: "/managed-data-identifiers/list", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about all the managed data identifiers that Amazon Macie currently provides.
    ///
    /// Parameters:
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func listManagedDataIdentifiers(
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListManagedDataIdentifiersResponse {
        let input = ListManagedDataIdentifiersRequest(
            nextToken: nextToken
        )
        return try await self.listManagedDataIdentifiers(input, logger: logger)
    }

    /// Retrieves information about the accounts that are associated with an Amazon Macie administrator account.
    @Sendable
    @inlinable
    public func listMembers(_ input: ListMembersRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListMembersResponse {
        try await self.client.execute(
            operation: "ListMembers", 
            path: "/members", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the accounts that are associated with an Amazon Macie administrator account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - onlyAssociated: Specifies which accounts to include in the response, based on the status of an account's relationship with the administrator account. By default, the response includes only current member accounts. To include all accounts, set this value to false.
    ///   - logger: Logger use during operation
    @inlinable
    public func listMembers(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        onlyAssociated: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListMembersResponse {
        let input = ListMembersRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            onlyAssociated: onlyAssociated
        )
        return try await self.listMembers(input, logger: logger)
    }

    /// Retrieves information about the delegated Amazon Macie administrator account for an organization in Organizations.
    @Sendable
    @inlinable
    public func listOrganizationAdminAccounts(_ input: ListOrganizationAdminAccountsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListOrganizationAdminAccountsResponse {
        try await self.client.execute(
            operation: "ListOrganizationAdminAccounts", 
            path: "/admin", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the delegated Amazon Macie administrator account for an organization in Organizations.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func listOrganizationAdminAccounts(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListOrganizationAdminAccountsResponse {
        let input = ListOrganizationAdminAccountsRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listOrganizationAdminAccounts(input, logger: logger)
    }

    /// Retrieves information about objects that Amazon Macie selected from an S3 bucket for automated sensitive data discovery.
    @Sendable
    @inlinable
    public func listResourceProfileArtifacts(_ input: ListResourceProfileArtifactsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListResourceProfileArtifactsResponse {
        try await self.client.execute(
            operation: "ListResourceProfileArtifacts", 
            path: "/resource-profiles/artifacts", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about objects that Amazon Macie selected from an S3 bucket for automated sensitive data discovery.
    ///
    /// Parameters:
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - resourceArn: The Amazon Resource Name (ARN) of the S3 bucket that the request applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func listResourceProfileArtifacts(
        nextToken: String? = nil,
        resourceArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListResourceProfileArtifactsResponse {
        let input = ListResourceProfileArtifactsRequest(
            nextToken: nextToken, 
            resourceArn: resourceArn
        )
        return try await self.listResourceProfileArtifacts(input, logger: logger)
    }

    /// Retrieves information about the types and amount of sensitive data that Amazon Macie found in an S3 bucket.
    @Sendable
    @inlinable
    public func listResourceProfileDetections(_ input: ListResourceProfileDetectionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListResourceProfileDetectionsResponse {
        try await self.client.execute(
            operation: "ListResourceProfileDetections", 
            path: "/resource-profiles/detections", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves information about the types and amount of sensitive data that Amazon Macie found in an S3 bucket.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - resourceArn: The Amazon Resource Name (ARN) of the S3 bucket that the request applies to.
    ///   - logger: Logger use during operation
    @inlinable
    public func listResourceProfileDetections(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        resourceArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListResourceProfileDetectionsResponse {
        let input = ListResourceProfileDetectionsRequest(
            maxResults: maxResults, 
            nextToken: nextToken, 
            resourceArn: resourceArn
        )
        return try await self.listResourceProfileDetections(input, logger: logger)
    }

    /// Retrieves a subset of information about the sensitivity inspection template for an account.
    @Sendable
    @inlinable
    public func listSensitivityInspectionTemplates(_ input: ListSensitivityInspectionTemplatesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListSensitivityInspectionTemplatesResponse {
        try await self.client.execute(
            operation: "ListSensitivityInspectionTemplates", 
            path: "/templates/sensitivity-inspections", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves a subset of information about the sensitivity inspection template for an account.
    ///
    /// Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - logger: Logger use during operation
    @inlinable
    public func listSensitivityInspectionTemplates(
        maxResults: Int? = nil,
        nextToken: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListSensitivityInspectionTemplatesResponse {
        let input = ListSensitivityInspectionTemplatesRequest(
            maxResults: maxResults, 
            nextToken: nextToken
        )
        return try await self.listSensitivityInspectionTemplates(input, logger: logger)
    }

    /// Retrieves the tags (keys and values) that are associated with an Amazon Macie resource.
    @Sendable
    @inlinable
    public func listTagsForResource(_ input: ListTagsForResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> ListTagsForResourceResponse {
        try await self.client.execute(
            operation: "ListTagsForResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .GET, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves the tags (keys and values) that are associated with an Amazon Macie resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - logger: Logger use during operation
    @inlinable
    public func listTagsForResource(
        resourceArn: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> ListTagsForResourceResponse {
        let input = ListTagsForResourceRequest(
            resourceArn: resourceArn
        )
        return try await self.listTagsForResource(input, logger: logger)
    }

    /// Adds or updates the configuration settings for storing data classification results.
    @Sendable
    @inlinable
    public func putClassificationExportConfiguration(_ input: PutClassificationExportConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutClassificationExportConfigurationResponse {
        try await self.client.execute(
            operation: "PutClassificationExportConfiguration", 
            path: "/classification-export-configuration", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds or updates the configuration settings for storing data classification results.
    ///
    /// Parameters:
    ///   - configuration: The location to store data classification results in, and the encryption settings to use when storing results in that location.
    ///   - logger: Logger use during operation
    @inlinable
    public func putClassificationExportConfiguration(
        configuration: ClassificationExportConfiguration? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutClassificationExportConfigurationResponse {
        let input = PutClassificationExportConfigurationRequest(
            configuration: configuration
        )
        return try await self.putClassificationExportConfiguration(input, logger: logger)
    }

    /// Updates the configuration settings for publishing findings to Security Hub.
    @Sendable
    @inlinable
    public func putFindingsPublicationConfiguration(_ input: PutFindingsPublicationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> PutFindingsPublicationConfigurationResponse {
        try await self.client.execute(
            operation: "PutFindingsPublicationConfiguration", 
            path: "/findings-publication-configuration", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the configuration settings for publishing findings to Security Hub.
    ///
    /// Parameters:
    ///   - clientToken: A unique, case-sensitive token that you provide to ensure the idempotency of the request.
    ///   - securityHubConfiguration: The configuration settings that determine which findings to publish to Security Hub.
    ///   - logger: Logger use during operation
    @inlinable
    public func putFindingsPublicationConfiguration(
        clientToken: String? = PutFindingsPublicationConfigurationRequest.idempotencyToken(),
        securityHubConfiguration: SecurityHubConfiguration? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> PutFindingsPublicationConfigurationResponse {
        let input = PutFindingsPublicationConfigurationRequest(
            clientToken: clientToken, 
            securityHubConfiguration: securityHubConfiguration
        )
        return try await self.putFindingsPublicationConfiguration(input, logger: logger)
    }

    /// Retrieves (queries) statistical data and other information about Amazon Web Services resources that Amazon Macie monitors and analyzes for an account.
    @Sendable
    @inlinable
    public func searchResources(_ input: SearchResourcesRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> SearchResourcesResponse {
        try await self.client.execute(
            operation: "SearchResources", 
            path: "/datasources/search-resources", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Retrieves (queries) statistical data and other information about Amazon Web Services resources that Amazon Macie monitors and analyzes for an account.
    ///
    /// Parameters:
    ///   - bucketCriteria: The filter conditions that determine which S3 buckets to include or exclude from the query results.
    ///   - maxResults: The maximum number of items to include in each page of the response. The default value is 50.
    ///   - nextToken: The nextToken string that specifies which page of results to return in a paginated response.
    ///   - sortCriteria: The criteria to use to sort the results.
    ///   - logger: Logger use during operation
    @inlinable
    public func searchResources(
        bucketCriteria: SearchResourcesBucketCriteria? = nil,
        maxResults: Int? = nil,
        nextToken: String? = nil,
        sortCriteria: SearchResourcesSortCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> SearchResourcesResponse {
        let input = SearchResourcesRequest(
            bucketCriteria: bucketCriteria, 
            maxResults: maxResults, 
            nextToken: nextToken, 
            sortCriteria: sortCriteria
        )
        return try await self.searchResources(input, logger: logger)
    }

    /// Adds or updates one or more tags (keys and values) that are associated with an Amazon Macie resource.
    @Sendable
    @inlinable
    public func tagResource(_ input: TagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TagResourceResponse {
        try await self.client.execute(
            operation: "TagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Adds or updates one or more tags (keys and values) that are associated with an Amazon Macie resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tags: A map of key-value pairs that specifies the tags to associate with the resource. A resource can have a maximum of 50 tags. Each tag consists of a tag key and an associated tag value. The maximum length of a tag key is 128 characters. The maximum length of a tag value is 256 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func tagResource(
        resourceArn: String,
        tags: [String: String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TagResourceResponse {
        let input = TagResourceRequest(
            resourceArn: resourceArn, 
            tags: tags
        )
        return try await self.tagResource(input, logger: logger)
    }

    /// Tests criteria for a custom data identifier.
    @Sendable
    @inlinable
    public func testCustomDataIdentifier(_ input: TestCustomDataIdentifierRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> TestCustomDataIdentifierResponse {
        try await self.client.execute(
            operation: "TestCustomDataIdentifier", 
            path: "/custom-data-identifiers/test", 
            httpMethod: .POST, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Tests criteria for a custom data identifier.
    ///
    /// Parameters:
    ///   - ignoreWords: An array that lists specific character sequences (ignore words) to exclude from the results. If the text matched by the regular expression contains any string in this array, Amazon Macie ignores it. The array can contain as many as 10 ignore words. Each ignore word can contain 4-90 UTF-8 characters. Ignore words are case sensitive.
    ///   - keywords: An array that lists specific character sequences (keywords), one of which must precede and be within proximity (maximumMatchDistance) of the regular expression to match. The array can contain as many as 50 keywords. Each keyword can contain 3-90 UTF-8 characters. Keywords aren't case sensitive.
    ///   - maximumMatchDistance: The maximum number of characters that can exist between the end of at least one complete character sequence specified by the keywords array and the end of the text that matches the regex pattern. If a complete keyword precedes all the text that matches the pattern and the keyword is within the specified distance, Amazon Macie includes the result. The distance can be 1-300 characters. The default value is 50.
    ///   - regex: The regular expression (regex) that defines the pattern to match. The expression can contain as many as 512 characters.
    ///   - sampleText: The sample text to inspect by using the custom data identifier. The text can contain as many as 1,000 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func testCustomDataIdentifier(
        ignoreWords: [String]? = nil,
        keywords: [String]? = nil,
        maximumMatchDistance: Int? = nil,
        regex: String? = nil,
        sampleText: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> TestCustomDataIdentifierResponse {
        let input = TestCustomDataIdentifierRequest(
            ignoreWords: ignoreWords, 
            keywords: keywords, 
            maximumMatchDistance: maximumMatchDistance, 
            regex: regex, 
            sampleText: sampleText
        )
        return try await self.testCustomDataIdentifier(input, logger: logger)
    }

    /// Removes one or more tags (keys and values) from an Amazon Macie resource.
    @Sendable
    @inlinable
    public func untagResource(_ input: UntagResourceRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UntagResourceResponse {
        try await self.client.execute(
            operation: "UntagResource", 
            path: "/tags/{resourceArn}", 
            httpMethod: .DELETE, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Removes one or more tags (keys and values) from an Amazon Macie resource.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the resource.
    ///   - tagKeys: One or more tags (keys) to remove from the resource. In an HTTP request to remove multiple tags, append the tagKeys parameter and argument for each tag to remove, separated by an ampersand (&amp;).
    ///   - logger: Logger use during operation
    @inlinable
    public func untagResource(
        resourceArn: String,
        tagKeys: [String]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UntagResourceResponse {
        let input = UntagResourceRequest(
            resourceArn: resourceArn, 
            tagKeys: tagKeys
        )
        return try await self.untagResource(input, logger: logger)
    }

    /// Updates the settings for an allow list.
    @Sendable
    @inlinable
    public func updateAllowList(_ input: UpdateAllowListRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAllowListResponse {
        try await self.client.execute(
            operation: "UpdateAllowList", 
            path: "/allow-lists/{id}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the settings for an allow list.
    ///
    /// Parameters:
    ///   - criteria: The criteria that specify the text or text pattern to ignore. The criteria can be the location and name of an S3 object that lists specific text to ignore (s3WordsList), or a regular expression that defines a text pattern to ignore (regex). You can change a list's underlying criteria, such as the name of the S3 object or the regular expression to use. However, you can't change the type from s3WordsList to regex or the other way around.
    ///   - description: A custom description of the allow list. The description can contain as many as 512 characters.
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - name: A custom name for the allow list. The name can contain as many as 128 characters.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAllowList(
        criteria: AllowListCriteria? = nil,
        description: String? = nil,
        id: String,
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAllowListResponse {
        let input = UpdateAllowListRequest(
            criteria: criteria, 
            description: description, 
            id: id, 
            name: name
        )
        return try await self.updateAllowList(input, logger: logger)
    }

    /// Changes the configuration settings and status of automated sensitive data discovery for an organization or standalone account.
    @Sendable
    @inlinable
    public func updateAutomatedDiscoveryConfiguration(_ input: UpdateAutomatedDiscoveryConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateAutomatedDiscoveryConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateAutomatedDiscoveryConfiguration", 
            path: "/automated-discovery/configuration", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Changes the configuration settings and status of automated sensitive data discovery for an organization or standalone account.
    ///
    /// Parameters:
    ///   - autoEnableOrganizationMembers: Specifies whether to automatically enable automated sensitive data discovery for accounts in the organization. Valid values are: ALL (default), enable it for all existing accounts and new member accounts; NEW, enable it only for new member accounts; and, NONE, don't enable it for any accounts. If you specify NEW or NONE, automated sensitive data discovery continues to be enabled for any existing accounts that it's currently enabled for. To enable or disable it for individual member accounts, specify NEW or NONE, and then enable or disable it for each account by using the BatchUpdateAutomatedDiscoveryAccounts operation.
    ///   - status: The new status of automated sensitive data discovery for the organization or account. Valid values are: ENABLED, start or resume all automated sensitive data discovery activities; and, DISABLED, stop performing all automated sensitive data discovery activities. If you specify DISABLED for an administrator account, you also disable automated sensitive data discovery for all member accounts in the organization.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateAutomatedDiscoveryConfiguration(
        autoEnableOrganizationMembers: AutoEnableMode? = nil,
        status: AutomatedDiscoveryStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateAutomatedDiscoveryConfigurationResponse {
        let input = UpdateAutomatedDiscoveryConfigurationRequest(
            autoEnableOrganizationMembers: autoEnableOrganizationMembers, 
            status: status
        )
        return try await self.updateAutomatedDiscoveryConfiguration(input, logger: logger)
    }

    /// Changes the status of a classification job.
    @Sendable
    @inlinable
    public func updateClassificationJob(_ input: UpdateClassificationJobRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateClassificationJobResponse {
        try await self.client.execute(
            operation: "UpdateClassificationJob", 
            path: "/jobs/{jobId}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Changes the status of a classification job.
    ///
    /// Parameters:
    ///   - jobId: The unique identifier for the classification job.
    ///   - jobStatus: The new status for the job. Valid values are: CANCELLED - Stops the job permanently and cancels it. This value is valid only if the job's current status is IDLE, PAUSED, RUNNING, or USER_PAUSED. If you specify this value and the job's current status is RUNNING, Amazon Macie immediately begins to stop all processing tasks for the job. You can't resume or restart a job after you cancel it. RUNNING - Resumes the job. This value is valid only if the job's current status is USER_PAUSED. If you paused the job while it was actively running and you specify this value less than 30 days after you paused the job, Macie immediately resumes processing from the point where you paused the job. Otherwise, Macie resumes the job according to the schedule and other settings for the job. USER_PAUSED - Pauses the job temporarily. This value is valid only if the job's current status is IDLE, PAUSED, or RUNNING. If you specify this value and the job's current status is RUNNING, Macie immediately begins to pause all processing tasks for the job. If you pause a one-time job and you don't resume it within 30 days, the job expires and Macie cancels the job. If you pause a recurring job when its status is RUNNING and you don't resume it within 30 days, the job run expires and Macie cancels the run. To check the expiration date, refer to the UserPausedDetails.jobExpiresAt property.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateClassificationJob(
        jobId: String,
        jobStatus: JobStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateClassificationJobResponse {
        let input = UpdateClassificationJobRequest(
            jobId: jobId, 
            jobStatus: jobStatus
        )
        return try await self.updateClassificationJob(input, logger: logger)
    }

    /// Updates the classification scope settings for an account.
    @Sendable
    @inlinable
    public func updateClassificationScope(_ input: UpdateClassificationScopeRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateClassificationScopeResponse {
        try await self.client.execute(
            operation: "UpdateClassificationScope", 
            path: "/classification-scopes/{id}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the classification scope settings for an account.
    ///
    /// Parameters:
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - s3: The S3 buckets to add or remove from the exclusion list defined by the classification scope.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateClassificationScope(
        id: String,
        s3: S3ClassificationScopeUpdate? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateClassificationScopeResponse {
        let input = UpdateClassificationScopeRequest(
            id: id, 
            s3: s3
        )
        return try await self.updateClassificationScope(input, logger: logger)
    }

    /// Updates the criteria and other settings for a findings filter.
    @Sendable
    @inlinable
    public func updateFindingsFilter(_ input: UpdateFindingsFilterRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateFindingsFilterResponse {
        try await self.client.execute(
            operation: "UpdateFindingsFilter", 
            path: "/findingsfilters/{id}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the criteria and other settings for a findings filter.
    ///
    /// Parameters:
    ///   - action: The action to perform on findings that match the filter criteria (findingCriteria). Valid values are: ARCHIVE, suppress (automatically archive) the findings; and, NOOP, don't perform any action on the findings.
    ///   - clientToken: A unique, case-sensitive token that you provide to ensure the idempotency of the request.
    ///   - description: A custom description of the filter. The description can contain as many as 512 characters. We strongly recommend that you avoid including any sensitive data in the description of a filter. Other users of your account might be able to see this description, depending on the actions that they're allowed to perform in Amazon Macie.
    ///   - findingCriteria: The criteria to use to filter findings.
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - name: A custom name for the filter. The name must contain at least 3 characters and can contain as many as 64 characters. We strongly recommend that you avoid including any sensitive data in the name of a filter. Other users of your account might be able to see this name, depending on the actions that they're allowed to perform in Amazon Macie.
    ///   - position: The position of the filter in the list of saved filters on the Amazon Macie console. This value also determines the order in which the filter is applied to findings, relative to other filters that are also applied to the findings.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateFindingsFilter(
        action: FindingsFilterAction? = nil,
        clientToken: String? = UpdateFindingsFilterRequest.idempotencyToken(),
        description: String? = nil,
        findingCriteria: FindingCriteria? = nil,
        id: String,
        name: String? = nil,
        position: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateFindingsFilterResponse {
        let input = UpdateFindingsFilterRequest(
            action: action, 
            clientToken: clientToken, 
            description: description, 
            findingCriteria: findingCriteria, 
            id: id, 
            name: name, 
            position: position
        )
        return try await self.updateFindingsFilter(input, logger: logger)
    }

    /// Suspends or re-enables Amazon Macie, or updates the configuration settings for a Macie account.
    @Sendable
    @inlinable
    public func updateMacieSession(_ input: UpdateMacieSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateMacieSessionResponse {
        try await self.client.execute(
            operation: "UpdateMacieSession", 
            path: "/macie", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Suspends or re-enables Amazon Macie, or updates the configuration settings for a Macie account.
    ///
    /// Parameters:
    ///   - findingPublishingFrequency: Specifies how often to publish updates to policy findings for the account. This includes publishing updates to Security Hub and Amazon EventBridge (formerly Amazon CloudWatch Events).
    ///   - status: Specifies a new status for the account. Valid values are: ENABLED, resume all Amazon Macie activities for the account; and, PAUSED, suspend all Macie activities for the account.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateMacieSession(
        findingPublishingFrequency: FindingPublishingFrequency? = nil,
        status: MacieStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateMacieSessionResponse {
        let input = UpdateMacieSessionRequest(
            findingPublishingFrequency: findingPublishingFrequency, 
            status: status
        )
        return try await self.updateMacieSession(input, logger: logger)
    }

    /// Enables an Amazon Macie administrator to suspend or re-enable Macie for a member account.
    @Sendable
    @inlinable
    public func updateMemberSession(_ input: UpdateMemberSessionRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateMemberSessionResponse {
        try await self.client.execute(
            operation: "UpdateMemberSession", 
            path: "/macie/members/{id}", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Enables an Amazon Macie administrator to suspend or re-enable Macie for a member account.
    ///
    /// Parameters:
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - status: Specifies the new status for the account. Valid values are: ENABLED, resume all Amazon Macie activities for the account; and, PAUSED, suspend all Macie activities for the account.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateMemberSession(
        id: String,
        status: MacieStatus? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateMemberSessionResponse {
        let input = UpdateMemberSessionRequest(
            id: id, 
            status: status
        )
        return try await self.updateMemberSession(input, logger: logger)
    }

    /// Updates the Amazon Macie configuration settings for an organization in Organizations.
    @Sendable
    @inlinable
    public func updateOrganizationConfiguration(_ input: UpdateOrganizationConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateOrganizationConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateOrganizationConfiguration", 
            path: "/admin/configuration", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the Amazon Macie configuration settings for an organization in Organizations.
    ///
    /// Parameters:
    ///   - autoEnable: Specifies whether to enable Amazon Macie automatically for accounts that are added to the organization in Organizations.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateOrganizationConfiguration(
        autoEnable: Bool? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateOrganizationConfigurationResponse {
        let input = UpdateOrganizationConfigurationRequest(
            autoEnable: autoEnable
        )
        return try await self.updateOrganizationConfiguration(input, logger: logger)
    }

    /// Updates the sensitivity score for an S3 bucket.
    @Sendable
    @inlinable
    public func updateResourceProfile(_ input: UpdateResourceProfileRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateResourceProfileResponse {
        try await self.client.execute(
            operation: "UpdateResourceProfile", 
            path: "/resource-profiles", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the sensitivity score for an S3 bucket.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the S3 bucket that the request applies to.
    ///   - sensitivityScoreOverride: The new sensitivity score for the bucket. Valid values are: 100, assign the maximum score and apply the Sensitive label to the bucket; and, null (empty), assign a score that Amazon Macie calculates automatically after you submit the request.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateResourceProfile(
        resourceArn: String? = nil,
        sensitivityScoreOverride: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateResourceProfileResponse {
        let input = UpdateResourceProfileRequest(
            resourceArn: resourceArn, 
            sensitivityScoreOverride: sensitivityScoreOverride
        )
        return try await self.updateResourceProfile(input, logger: logger)
    }

    /// Updates the sensitivity scoring settings for an S3 bucket.
    @Sendable
    @inlinable
    public func updateResourceProfileDetections(_ input: UpdateResourceProfileDetectionsRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateResourceProfileDetectionsResponse {
        try await self.client.execute(
            operation: "UpdateResourceProfileDetections", 
            path: "/resource-profiles/detections", 
            httpMethod: .PATCH, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the sensitivity scoring settings for an S3 bucket.
    ///
    /// Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the S3 bucket that the request applies to.
    ///   - suppressDataIdentifiers: An array of objects, one for each custom data identifier or managed data identifier that detected a type of sensitive data to exclude from the bucket's score. To include all sensitive data types in the score, don't specify any values for this array.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateResourceProfileDetections(
        resourceArn: String? = nil,
        suppressDataIdentifiers: [SuppressDataIdentifier]? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateResourceProfileDetectionsResponse {
        let input = UpdateResourceProfileDetectionsRequest(
            resourceArn: resourceArn, 
            suppressDataIdentifiers: suppressDataIdentifiers
        )
        return try await self.updateResourceProfileDetections(input, logger: logger)
    }

    /// Updates the status and configuration settings for retrieving occurrences of sensitive data reported by findings.
    @Sendable
    @inlinable
    public func updateRevealConfiguration(_ input: UpdateRevealConfigurationRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateRevealConfigurationResponse {
        try await self.client.execute(
            operation: "UpdateRevealConfiguration", 
            path: "/reveal-configuration", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the status and configuration settings for retrieving occurrences of sensitive data reported by findings.
    ///
    /// Parameters:
    ///   - configuration: The KMS key to use to encrypt the sensitive data, and the status of the configuration for the Amazon Macie account.
    ///   - retrievalConfiguration: The access method and settings to use when retrieving the sensitive data.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateRevealConfiguration(
        configuration: RevealConfiguration? = nil,
        retrievalConfiguration: UpdateRetrievalConfiguration? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateRevealConfigurationResponse {
        let input = UpdateRevealConfigurationRequest(
            configuration: configuration, 
            retrievalConfiguration: retrievalConfiguration
        )
        return try await self.updateRevealConfiguration(input, logger: logger)
    }

    /// Updates the settings for the sensitivity inspection template for an account.
    @Sendable
    @inlinable
    public func updateSensitivityInspectionTemplate(_ input: UpdateSensitivityInspectionTemplateRequest, logger: Logger = AWSClient.loggingDisabled) async throws -> UpdateSensitivityInspectionTemplateResponse {
        try await self.client.execute(
            operation: "UpdateSensitivityInspectionTemplate", 
            path: "/templates/sensitivity-inspections/{id}", 
            httpMethod: .PUT, 
            serviceConfig: self.config, 
            input: input, 
            logger: logger
        )
    }
    /// Updates the settings for the sensitivity inspection template for an account.
    ///
    /// Parameters:
    ///   - description: A custom description of the template. The description can contain as many as 200 characters.
    ///   - excludes: The managed data identifiers to explicitly exclude (not use) when performing automated sensitive data discovery. To exclude an allow list or custom data identifier that's currently included by the template, update the values for the SensitivityInspectionTemplateIncludes.allowListIds and SensitivityInspectionTemplateIncludes.customDataIdentifierIds properties, respectively.
    ///   - id: The unique identifier for the Amazon Macie resource that the request applies to.
    ///   - includes: The allow lists, custom data identifiers, and managed data identifiers to explicitly include (use) when performing automated sensitive data discovery.
    ///   - logger: Logger use during operation
    @inlinable
    public func updateSensitivityInspectionTemplate(
        description: String? = nil,
        excludes: SensitivityInspectionTemplateExcludes? = nil,
        id: String,
        includes: SensitivityInspectionTemplateIncludes? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws -> UpdateSensitivityInspectionTemplateResponse {
        let input = UpdateSensitivityInspectionTemplateRequest(
            description: description, 
            excludes: excludes, 
            id: id, 
            includes: includes
        )
        return try await self.updateSensitivityInspectionTemplate(input, logger: logger)
    }
}

extension Macie2 {
    /// Initializer required by `AWSService.with(middlewares:timeout:byteBufferAllocator:options)`. You are not able to use this initializer directly as there are not public
    /// initializers for `AWSServiceConfig.Patch`. Please use `AWSService.with(middlewares:timeout:byteBufferAllocator:options)` instead.
    public init(from: Macie2, patch: AWSServiceConfig.Patch) {
        self.client = from.client
        self.config = from.config.with(patch: patch)
    }
}

// MARK: Paginators

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Macie2 {
    /// Return PaginatorSequence for operation ``describeBuckets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBucketsPaginator(
        _ input: DescribeBucketsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<DescribeBucketsRequest, DescribeBucketsResponse> {
        return .init(
            input: input,
            command: self.describeBuckets,
            inputKey: \DescribeBucketsRequest.nextToken,
            outputKey: \DescribeBucketsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``describeBuckets(_:logger:)``.
    ///
    /// - Parameters:
    ///   - criteria: The criteria to use to filter the query results.
    ///   - maxResults: The maximum number of items to include in each page of the response. The default value is 50.
    ///   - sortCriteria: The criteria to use to sort the query results.
    ///   - logger: Logger used for logging
    @inlinable
    public func describeBucketsPaginator(
        criteria: [String: BucketCriteriaAdditionalProperties]? = nil,
        maxResults: Int? = nil,
        sortCriteria: BucketSortCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<DescribeBucketsRequest, DescribeBucketsResponse> {
        let input = DescribeBucketsRequest(
            criteria: criteria, 
            maxResults: maxResults, 
            sortCriteria: sortCriteria
        )
        return self.describeBucketsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``getUsageStatistics(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func getUsageStatisticsPaginator(
        _ input: GetUsageStatisticsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<GetUsageStatisticsRequest, GetUsageStatisticsResponse> {
        return .init(
            input: input,
            command: self.getUsageStatistics,
            inputKey: \GetUsageStatisticsRequest.nextToken,
            outputKey: \GetUsageStatisticsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``getUsageStatistics(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filterBy: An array of objects, one for each condition to use to filter the query results. If you specify more than one condition, Amazon Macie uses an AND operator to join the conditions.
    ///   - maxResults: The maximum number of items to include in each page of the response.
    ///   - sortBy: The criteria to use to sort the query results.
    ///   - timeRange: The inclusive time period to query usage data for. Valid values are: MONTH_TO_DATE, for the current calendar month to date; and, PAST_30_DAYS, for the preceding 30 days. If you don't specify a value, Amazon Macie provides usage data for the preceding 30 days.
    ///   - logger: Logger used for logging
    @inlinable
    public func getUsageStatisticsPaginator(
        filterBy: [UsageStatisticsFilter]? = nil,
        maxResults: Int? = nil,
        sortBy: UsageStatisticsSortBy? = nil,
        timeRange: TimeRange? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<GetUsageStatisticsRequest, GetUsageStatisticsResponse> {
        let input = GetUsageStatisticsRequest(
            filterBy: filterBy, 
            maxResults: maxResults, 
            sortBy: sortBy, 
            timeRange: timeRange
        )
        return self.getUsageStatisticsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAllowLists(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAllowListsPaginator(
        _ input: ListAllowListsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAllowListsRequest, ListAllowListsResponse> {
        return .init(
            input: input,
            command: self.listAllowLists,
            inputKey: \ListAllowListsRequest.nextToken,
            outputKey: \ListAllowListsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAllowLists(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAllowListsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAllowListsRequest, ListAllowListsResponse> {
        let input = ListAllowListsRequest(
            maxResults: maxResults
        )
        return self.listAllowListsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listAutomatedDiscoveryAccounts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listAutomatedDiscoveryAccountsPaginator(
        _ input: ListAutomatedDiscoveryAccountsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListAutomatedDiscoveryAccountsRequest, ListAutomatedDiscoveryAccountsResponse> {
        return .init(
            input: input,
            command: self.listAutomatedDiscoveryAccounts,
            inputKey: \ListAutomatedDiscoveryAccountsRequest.nextToken,
            outputKey: \ListAutomatedDiscoveryAccountsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listAutomatedDiscoveryAccounts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - accountIds: The Amazon Web Services account ID for each account, for as many as 50 accounts. To retrieve the status for multiple accounts, append the accountIds parameter and argument for each account, separated by an ampersand (&amp;). To retrieve the status for all the accounts in an organization, omit this parameter.
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listAutomatedDiscoveryAccountsPaginator(
        accountIds: [String]? = nil,
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListAutomatedDiscoveryAccountsRequest, ListAutomatedDiscoveryAccountsResponse> {
        let input = ListAutomatedDiscoveryAccountsRequest(
            accountIds: accountIds, 
            maxResults: maxResults
        )
        return self.listAutomatedDiscoveryAccountsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listClassificationJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listClassificationJobsPaginator(
        _ input: ListClassificationJobsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListClassificationJobsRequest, ListClassificationJobsResponse> {
        return .init(
            input: input,
            command: self.listClassificationJobs,
            inputKey: \ListClassificationJobsRequest.nextToken,
            outputKey: \ListClassificationJobsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listClassificationJobs(_:logger:)``.
    ///
    /// - Parameters:
    ///   - filterCriteria: The criteria to use to filter the results.
    ///   - maxResults: The maximum number of items to include in each page of the response.
    ///   - sortCriteria: The criteria to use to sort the results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listClassificationJobsPaginator(
        filterCriteria: ListJobsFilterCriteria? = nil,
        maxResults: Int? = nil,
        sortCriteria: ListJobsSortCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListClassificationJobsRequest, ListClassificationJobsResponse> {
        let input = ListClassificationJobsRequest(
            filterCriteria: filterCriteria, 
            maxResults: maxResults, 
            sortCriteria: sortCriteria
        )
        return self.listClassificationJobsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listClassificationScopes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listClassificationScopesPaginator(
        _ input: ListClassificationScopesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListClassificationScopesRequest, ListClassificationScopesResponse> {
        return .init(
            input: input,
            command: self.listClassificationScopes,
            inputKey: \ListClassificationScopesRequest.nextToken,
            outputKey: \ListClassificationScopesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listClassificationScopes(_:logger:)``.
    ///
    /// - Parameters:
    ///   - name: The name of the classification scope to retrieve the unique identifier for.
    ///   - logger: Logger used for logging
    @inlinable
    public func listClassificationScopesPaginator(
        name: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListClassificationScopesRequest, ListClassificationScopesResponse> {
        let input = ListClassificationScopesRequest(
            name: name
        )
        return self.listClassificationScopesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listCustomDataIdentifiers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listCustomDataIdentifiersPaginator(
        _ input: ListCustomDataIdentifiersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListCustomDataIdentifiersRequest, ListCustomDataIdentifiersResponse> {
        return .init(
            input: input,
            command: self.listCustomDataIdentifiers,
            inputKey: \ListCustomDataIdentifiersRequest.nextToken,
            outputKey: \ListCustomDataIdentifiersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listCustomDataIdentifiers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of items to include in each page of the response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listCustomDataIdentifiersPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListCustomDataIdentifiersRequest, ListCustomDataIdentifiersResponse> {
        let input = ListCustomDataIdentifiersRequest(
            maxResults: maxResults
        )
        return self.listCustomDataIdentifiersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listFindings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listFindingsPaginator(
        _ input: ListFindingsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListFindingsRequest, ListFindingsResponse> {
        return .init(
            input: input,
            command: self.listFindings,
            inputKey: \ListFindingsRequest.nextToken,
            outputKey: \ListFindingsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listFindings(_:logger:)``.
    ///
    /// - Parameters:
    ///   - findingCriteria: The criteria to use to filter the results.
    ///   - maxResults: The maximum number of items to include in each page of the response.
    ///   - sortCriteria: The criteria to use to sort the results.
    ///   - logger: Logger used for logging
    @inlinable
    public func listFindingsPaginator(
        findingCriteria: FindingCriteria? = nil,
        maxResults: Int? = nil,
        sortCriteria: SortCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListFindingsRequest, ListFindingsResponse> {
        let input = ListFindingsRequest(
            findingCriteria: findingCriteria, 
            maxResults: maxResults, 
            sortCriteria: sortCriteria
        )
        return self.listFindingsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listFindingsFilters(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listFindingsFiltersPaginator(
        _ input: ListFindingsFiltersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListFindingsFiltersRequest, ListFindingsFiltersResponse> {
        return .init(
            input: input,
            command: self.listFindingsFilters,
            inputKey: \ListFindingsFiltersRequest.nextToken,
            outputKey: \ListFindingsFiltersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listFindingsFilters(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listFindingsFiltersPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListFindingsFiltersRequest, ListFindingsFiltersResponse> {
        let input = ListFindingsFiltersRequest(
            maxResults: maxResults
        )
        return self.listFindingsFiltersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listInvitations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listInvitationsPaginator(
        _ input: ListInvitationsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListInvitationsRequest, ListInvitationsResponse> {
        return .init(
            input: input,
            command: self.listInvitations,
            inputKey: \ListInvitationsRequest.nextToken,
            outputKey: \ListInvitationsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listInvitations(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listInvitationsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListInvitationsRequest, ListInvitationsResponse> {
        let input = ListInvitationsRequest(
            maxResults: maxResults
        )
        return self.listInvitationsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listManagedDataIdentifiers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedDataIdentifiersPaginator(
        _ input: ListManagedDataIdentifiersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListManagedDataIdentifiersRequest, ListManagedDataIdentifiersResponse> {
        return .init(
            input: input,
            command: self.listManagedDataIdentifiers,
            inputKey: \ListManagedDataIdentifiersRequest.nextToken,
            outputKey: \ListManagedDataIdentifiersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listManagedDataIdentifiers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - logger: Logger used for logging
    @inlinable
    public func listManagedDataIdentifiersPaginator(
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListManagedDataIdentifiersRequest, ListManagedDataIdentifiersResponse> {
        let input = ListManagedDataIdentifiersRequest(
        )
        return self.listManagedDataIdentifiersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listMembers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listMembersPaginator(
        _ input: ListMembersRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListMembersRequest, ListMembersResponse> {
        return .init(
            input: input,
            command: self.listMembers,
            inputKey: \ListMembersRequest.nextToken,
            outputKey: \ListMembersResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listMembers(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - onlyAssociated: Specifies which accounts to include in the response, based on the status of an account's relationship with the administrator account. By default, the response includes only current member accounts. To include all accounts, set this value to false.
    ///   - logger: Logger used for logging
    @inlinable
    public func listMembersPaginator(
        maxResults: Int? = nil,
        onlyAssociated: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListMembersRequest, ListMembersResponse> {
        let input = ListMembersRequest(
            maxResults: maxResults, 
            onlyAssociated: onlyAssociated
        )
        return self.listMembersPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listOrganizationAdminAccounts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listOrganizationAdminAccountsPaginator(
        _ input: ListOrganizationAdminAccountsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListOrganizationAdminAccountsRequest, ListOrganizationAdminAccountsResponse> {
        return .init(
            input: input,
            command: self.listOrganizationAdminAccounts,
            inputKey: \ListOrganizationAdminAccountsRequest.nextToken,
            outputKey: \ListOrganizationAdminAccountsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listOrganizationAdminAccounts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listOrganizationAdminAccountsPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListOrganizationAdminAccountsRequest, ListOrganizationAdminAccountsResponse> {
        let input = ListOrganizationAdminAccountsRequest(
            maxResults: maxResults
        )
        return self.listOrganizationAdminAccountsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listResourceProfileArtifacts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourceProfileArtifactsPaginator(
        _ input: ListResourceProfileArtifactsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListResourceProfileArtifactsRequest, ListResourceProfileArtifactsResponse> {
        return .init(
            input: input,
            command: self.listResourceProfileArtifacts,
            inputKey: \ListResourceProfileArtifactsRequest.nextToken,
            outputKey: \ListResourceProfileArtifactsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listResourceProfileArtifacts(_:logger:)``.
    ///
    /// - Parameters:
    ///   - resourceArn: The Amazon Resource Name (ARN) of the S3 bucket that the request applies to.
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourceProfileArtifactsPaginator(
        resourceArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListResourceProfileArtifactsRequest, ListResourceProfileArtifactsResponse> {
        let input = ListResourceProfileArtifactsRequest(
            resourceArn: resourceArn
        )
        return self.listResourceProfileArtifactsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listResourceProfileDetections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourceProfileDetectionsPaginator(
        _ input: ListResourceProfileDetectionsRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListResourceProfileDetectionsRequest, ListResourceProfileDetectionsResponse> {
        return .init(
            input: input,
            command: self.listResourceProfileDetections,
            inputKey: \ListResourceProfileDetectionsRequest.nextToken,
            outputKey: \ListResourceProfileDetectionsResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listResourceProfileDetections(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - resourceArn: The Amazon Resource Name (ARN) of the S3 bucket that the request applies to.
    ///   - logger: Logger used for logging
    @inlinable
    public func listResourceProfileDetectionsPaginator(
        maxResults: Int? = nil,
        resourceArn: String? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListResourceProfileDetectionsRequest, ListResourceProfileDetectionsResponse> {
        let input = ListResourceProfileDetectionsRequest(
            maxResults: maxResults, 
            resourceArn: resourceArn
        )
        return self.listResourceProfileDetectionsPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``listSensitivityInspectionTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func listSensitivityInspectionTemplatesPaginator(
        _ input: ListSensitivityInspectionTemplatesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<ListSensitivityInspectionTemplatesRequest, ListSensitivityInspectionTemplatesResponse> {
        return .init(
            input: input,
            command: self.listSensitivityInspectionTemplates,
            inputKey: \ListSensitivityInspectionTemplatesRequest.nextToken,
            outputKey: \ListSensitivityInspectionTemplatesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``listSensitivityInspectionTemplates(_:logger:)``.
    ///
    /// - Parameters:
    ///   - maxResults: The maximum number of items to include in each page of a paginated response.
    ///   - logger: Logger used for logging
    @inlinable
    public func listSensitivityInspectionTemplatesPaginator(
        maxResults: Int? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<ListSensitivityInspectionTemplatesRequest, ListSensitivityInspectionTemplatesResponse> {
        let input = ListSensitivityInspectionTemplatesRequest(
            maxResults: maxResults
        )
        return self.listSensitivityInspectionTemplatesPaginator(input, logger: logger)
    }

    /// Return PaginatorSequence for operation ``searchResources(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func searchResourcesPaginator(
        _ input: SearchResourcesRequest,
        logger: Logger = AWSClient.loggingDisabled
    ) -> AWSClient.PaginatorSequence<SearchResourcesRequest, SearchResourcesResponse> {
        return .init(
            input: input,
            command: self.searchResources,
            inputKey: \SearchResourcesRequest.nextToken,
            outputKey: \SearchResourcesResponse.nextToken,
            logger: logger
        )
    }
    /// Return PaginatorSequence for operation ``searchResources(_:logger:)``.
    ///
    /// - Parameters:
    ///   - bucketCriteria: The filter conditions that determine which S3 buckets to include or exclude from the query results.
    ///   - maxResults: The maximum number of items to include in each page of the response. The default value is 50.
    ///   - sortCriteria: The criteria to use to sort the results.
    ///   - logger: Logger used for logging
    @inlinable
    public func searchResourcesPaginator(
        bucketCriteria: SearchResourcesBucketCriteria? = nil,
        maxResults: Int? = nil,
        sortCriteria: SearchResourcesSortCriteria? = nil,
        logger: Logger = AWSClient.loggingDisabled        
    ) -> AWSClient.PaginatorSequence<SearchResourcesRequest, SearchResourcesResponse> {
        let input = SearchResourcesRequest(
            bucketCriteria: bucketCriteria, 
            maxResults: maxResults, 
            sortCriteria: sortCriteria
        )
        return self.searchResourcesPaginator(input, logger: logger)
    }
}

extension Macie2.DescribeBucketsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.DescribeBucketsRequest {
        return .init(
            criteria: self.criteria,
            maxResults: self.maxResults,
            nextToken: token,
            sortCriteria: self.sortCriteria
        )
    }
}

extension Macie2.GetUsageStatisticsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.GetUsageStatisticsRequest {
        return .init(
            filterBy: self.filterBy,
            maxResults: self.maxResults,
            nextToken: token,
            sortBy: self.sortBy,
            timeRange: self.timeRange
        )
    }
}

extension Macie2.ListAllowListsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListAllowListsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Macie2.ListAutomatedDiscoveryAccountsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListAutomatedDiscoveryAccountsRequest {
        return .init(
            accountIds: self.accountIds,
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Macie2.ListClassificationJobsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListClassificationJobsRequest {
        return .init(
            filterCriteria: self.filterCriteria,
            maxResults: self.maxResults,
            nextToken: token,
            sortCriteria: self.sortCriteria
        )
    }
}

extension Macie2.ListClassificationScopesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListClassificationScopesRequest {
        return .init(
            name: self.name,
            nextToken: token
        )
    }
}

extension Macie2.ListCustomDataIdentifiersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListCustomDataIdentifiersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Macie2.ListFindingsFiltersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListFindingsFiltersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Macie2.ListFindingsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListFindingsRequest {
        return .init(
            findingCriteria: self.findingCriteria,
            maxResults: self.maxResults,
            nextToken: token,
            sortCriteria: self.sortCriteria
        )
    }
}

extension Macie2.ListInvitationsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListInvitationsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Macie2.ListManagedDataIdentifiersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListManagedDataIdentifiersRequest {
        return .init(
            nextToken: token
        )
    }
}

extension Macie2.ListMembersRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListMembersRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            onlyAssociated: self.onlyAssociated
        )
    }
}

extension Macie2.ListOrganizationAdminAccountsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListOrganizationAdminAccountsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Macie2.ListResourceProfileArtifactsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListResourceProfileArtifactsRequest {
        return .init(
            nextToken: token,
            resourceArn: self.resourceArn
        )
    }
}

extension Macie2.ListResourceProfileDetectionsRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListResourceProfileDetectionsRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token,
            resourceArn: self.resourceArn
        )
    }
}

extension Macie2.ListSensitivityInspectionTemplatesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.ListSensitivityInspectionTemplatesRequest {
        return .init(
            maxResults: self.maxResults,
            nextToken: token
        )
    }
}

extension Macie2.SearchResourcesRequest: AWSPaginateToken {
    @inlinable
    public func usingPaginationToken(_ token: String) -> Macie2.SearchResourcesRequest {
        return .init(
            bucketCriteria: self.bucketCriteria,
            maxResults: self.maxResults,
            nextToken: token,
            sortCriteria: self.sortCriteria
        )
    }
}

// MARK: Waiters

@available(macOS 10.15, iOS 13.0, tvOS 13.0, watchOS 6.0, *)
extension Macie2 {
    /// Waiter for operation ``getSensitiveDataOccurrences(_:logger:)``.
    ///
    /// - Parameters:
    ///   - input: Input for operation
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilFindingRevealed(
        _ input: GetSensitiveDataOccurrencesRequest,
        maxWaitTime: TimeAmount? = nil,
        logger: Logger = AWSClient.loggingDisabled
    ) async throws {
        let waiter = AWSClient.Waiter<GetSensitiveDataOccurrencesRequest, _>(
            acceptors: [
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "SUCCESS")),
                .init(state: .success, matcher: try! JMESPathMatcher("status", expected: "ERROR")),
            ],
            command: self.getSensitiveDataOccurrences
        )
        return try await self.client.waitUntil(input, waiter: waiter, maxWaitTime: maxWaitTime, logger: logger)
    }
    /// Waiter for operation ``getSensitiveDataOccurrences(_:logger:)``.
    ///
    /// - Parameters:
    ///   - findingId: The unique identifier for the finding.
    ///   - logger: Logger used for logging
    @inlinable
    public func waitUntilFindingRevealed(
        findingId: String,
        logger: Logger = AWSClient.loggingDisabled        
    ) async throws {
        let input = GetSensitiveDataOccurrencesRequest(
            findingId: findingId
        )
        try await self.waitUntilFindingRevealed(input, logger: logger)
    }
}
